Update app.py

app.py

@@ -23,7 +23,9 @@ import io
 import json
 import os
 import re
+import shutil
 import subprocess
+import sys
 import time
 import urllib.parse
 import threading
@@ -415,31 +417,32 @@ def _is_black_screen(img) -> bool:
         return False
 
 
-def _capture_raw(display: str) -> tuple:
-    """يلتقط الشاشة من display محدد."""
+def _load_capture_image(path: str):
+    from PIL import Image
+    if not path or not os.path.exists(path):
+        return None, 0, 0
+    if os.path.getsize(path) < 1024:
+        return None, 0, 0
+    try:
+        img = Image.open(path).convert("RGB")
+        w, h = img.size
+        if w < 100 or h < 100:
+            return None, 0, 0
+        return img, w, h
+    except Exception as ex:
+        print(f"[cap] load error for {path}: {ex}")
+        return None, 0, 0
+
+
+def _capture_via_x11_stack(display: str):
+    """الطريقة الأولى: scrot → ImageMagick import → ffmpeg x11grab → python-xlib."""
     from PIL import Image
     env = {**os.environ, "DISPLAY": display}
     ts = int(time.time() * 1000)
-    # استخدم display number في اسم الملف لتفادي التعارض
     disp_safe = display.replace(":", "")
     tmp_base = f"/tmp/zss_{disp_safe}_{ts}"
     created_files = []
 
-    def _try_load(path) -> tuple:
-        if not path or not os.path.exists(path):
-            return None, 0, 0
-        if os.path.getsize(path) < 1024:
-            return None, 0, 0
-        try:
-            img = Image.open(path).convert("RGB")
-            w, h = img.size
-            if w < 100 or h < 100:
-                return None, 0, 0
-            return img, w, h
-        except Exception as ex:
-            print(f"[cap:{display}] load error: {ex}")
-            return None, 0, 0
-
     def _cleanup_files():
         for p in created_files:
             try:
@@ -448,76 +451,144 @@ def _capture_raw(display: str) -> tuple:
             except Exception:
                 pass
 
-    for attempt in range(3):
-        if attempt > 0:
-            time.sleep(0.8)
-            print(f"[cap:{display}] retry attempt {attempt+1} (black screen)")
+    try:
+        p1 = f"{tmp_base}_scrot.png"
+        created_files.append(p1)
         try:
-            # Method 1: scrot
-            p1 = f"{tmp_base}_a{attempt}_scrot.png"
-            created_files.append(p1)
-            try:
-                subprocess.run(["scrot", "-q", "95", p1],
-                    env=env, timeout=8, capture_output=True)
-                img, w, h = _try_load(p1)
-                if img and not _is_black_screen(img):
-                    return img, w, h
-            except Exception as e:
-                print(f"[cap:{display}] scrot: {e}")
+            subprocess.run(["scrot", "-q", "95", p1], env=env, timeout=8, capture_output=True)
+            img, w, h = _load_capture_image(p1)
+            if img and not _is_black_screen(img):
+                return img, w, h
+        except Exception as e:
+            print(f"[cap:{display}] scrot: {e}")
 
-            # Method 2: ImageMagick import
-            p2 = f"{tmp_base}_a{attempt}_im.png"
-            created_files.append(p2)
-            try:
-                subprocess.run(["import", "-window", "root", "-silent", p2],
-                    env=env, timeout=10, capture_output=True)
-                img, w, h = _try_load(p2)
-                if img and not _is_black_screen(img):
-                    return img, w, h
-            except Exception as e:
-                print(f"[cap:{display}] import: {e}")
+        p2 = f"{tmp_base}_im.png"
+        created_files.append(p2)
+        try:
+            subprocess.run(["import", "-window", "root", "-silent", p2], env=env, timeout=10, capture_output=True)
+            img, w, h = _load_capture_image(p2)
+            if img and not _is_black_screen(img):
+                return img, w, h
+        except Exception as e:
+            print(f"[cap:{display}] import: {e}")
+
+        p3 = f"{tmp_base}_ff.png"
+        created_files.append(p3)
+        try:
+            sw, sh = _get_screen_size(display)
+            subprocess.run([
+                "ffmpeg", "-y", "-f", "x11grab",
+                "-video_size", f"{sw}x{sh}",
+                "-i", display,
+                "-vframes", "1", "-q:v", "1", p3
+            ], env=env, timeout=12, capture_output=True)
+            img, w, h = _load_capture_image(p3)
+            if img and not _is_black_screen(img):
+                return img, w, h
+        except Exception as e:
+            print(f"[cap:{display}] ffmpeg: {e}")
+
+        try:
+            from Xlib import display as Xdisp, X
+            xd = Xdisp.Display(display)
+            root = xd.screen().root
+            geom = root.get_geometry()
+            w, h = geom.width, geom.height
+            raw = root.get_image(0, 0, w, h, X.ZPixmap, 0xFFFFFFFF)
+            data = raw.data
+            pixels = bytearray(len(data) // 4 * 3)
+            for i in range(0, len(data) - 3, 4):
+                b, g, r_c = data[i], data[i+1], data[i+2]
+                j = (i // 4) * 3
+                pixels[j], pixels[j+1], pixels[j+2] = r_c, g, b
+            img = Image.frombytes("RGB", (w, h), bytes(pixels))
+            if not _is_black_screen(img):
+                return img, w, h
+        except Exception as e:
+            print(f"[cap:{display}] xlib: {e}")
+
+        return None, 0, 0
+    finally:
+        _cleanup_files()
 
-            # Method 3: ffmpeg x11grab
-            p3 = f"{tmp_base}_a{attempt}_ff.png"
-            created_files.append(p3)
+
+def _capture_via_xwd(display: str):
+    """الطريقة الثانية: xwd ثم convert إلى PNG."""
+    env = {**os.environ, "DISPLAY": display}
+    ts = int(time.time() * 1000)
+    disp_safe = display.replace(":", "")
+    xwd_path = f"/tmp/zss_{disp_safe}_{ts}.xwd"
+    png_path = f"/tmp/zss_{disp_safe}_{ts}.png"
+    try:
+        with open(xwd_path, "wb") as f:
+            subprocess.run(["xwd", "-root", "-silent"], env=env, stdout=f, stderr=subprocess.PIPE, timeout=12)
+        subprocess.run(["convert", xwd_path, png_path], env=env, capture_output=True, timeout=15)
+        img, w, h = _load_capture_image(png_path)
+        if img and not _is_black_screen(img):
+            return img, w, h
+    except FileNotFoundError as e:
+        print(f"[cap:{display}] xwd/convert not found: {e}")
+    except Exception as e:
+        print(f"[cap:{display}] xwd: {e}")
+    finally:
+        for p in (xwd_path, png_path):
             try:
-                sw, sh = _get_screen_size(display)
-                subprocess.run([
-                    "ffmpeg", "-y", "-f", "x11grab",
-                    "-video_size", f"{sw}x{sh}",
-                    "-i", display,
-                    "-vframes", "1", "-q:v", "1", p3
-                ], env=env, timeout=12, capture_output=True)
-                img, w, h = _try_load(p3)
-                if img and not _is_black_screen(img):
-                    return img, w, h
-            except Exception as e:
-                print(f"[cap:{display}] ffmpeg: {e}")
+                if os.path.exists(p):
+                    os.unlink(p)
+            except Exception:
+                pass
+    return None, 0, 0
 
-            # Method 4: python-xlib
+
+def _capture_via_pyscreenshot(display: str):
+    """الطريقة الثالثة: pyscreenshot backend من داخل Python."""
+    ts = int(time.time() * 1000)
+    disp_safe = display.replace(":", "")
+    png_path = f"/tmp/zss_{disp_safe}_{ts}_pyshot.png"
+    env = {**os.environ, "DISPLAY": display}
+    try:
+        code = """import sys
+from pyscreenshot import grab
+out = sys.argv[1]
+img = grab()
+img.save(out)
+"""
+        subprocess.run([sys.executable, "-c", code, png_path], env=env, capture_output=True, timeout=18)
+        img, w, h = _load_capture_image(png_path)
+        if img and not _is_black_screen(img):
+            return img, w, h
+    except FileNotFoundError as e:
+        print(f"[cap:{display}] pyscreenshot not available: {e}")
+    except Exception as e:
+        print(f"[cap:{display}] pyscreenshot: {e}")
+    finally:
+        try:
+            if os.path.exists(png_path):
+                os.unlink(png_path)
+        except Exception:
+            pass
+    return None, 0, 0
+
+
+def _capture_raw(display: str) -> tuple:
+    """يلتقط الشاشة من display محدد عبر 3 طرق مستقلة."""
+    for attempt in range(3):
+        if attempt > 0:
+            time.sleep(0.8)
+            print(f"[cap:{display}] retry attempt {attempt+1}")
+        for method_name, method in (
+            ("x11-stack", _capture_via_x11_stack),
+            ("xwd", _capture_via_xwd),
+            ("pyscreenshot", _capture_via_pyscreenshot),
+        ):
             try:
-                from Xlib import display as Xdisp, X
-                xd = Xdisp.Display(display)
-                root = xd.screen().root
-                geom = root.get_geometry()
-                w, h = geom.width, geom.height
-                raw = root.get_image(0, 0, w, h, X.ZPixmap, 0xFFFFFFFF)
-                data = raw.data
-                pixels = bytearray(len(data) // 4 * 3)
-                for i in range(0, len(data) - 3, 4):
-                    b, g, r_c = data[i], data[i+1], data[i+2]
-                    j = (i // 4) * 3
-                    pixels[j], pixels[j+1], pixels[j+2] = r_c, g, b
-                img = Image.frombytes("RGB", (w, h), bytes(pixels))
-                if not _is_black_screen(img):
+                img, w, h = method(display)
+                if img and not _is_black_screen(img):
+                    print(f"[cap:{display}] ✅ {method_name} succeeded on attempt {attempt+1}")
                     return img, w, h
             except Exception as e:
-                print(f"[cap:{display}] xlib: {e}")
+                print(f"[cap:{display}] {method_name}: {e}")
 
-        finally:
-            _cleanup_files()
-
-    # Placeholder
     print(f"[cap:{display}] ⚠️ All methods failed — placeholder")
     from PIL import Image as PILImg, ImageDraw
     sw, sh = _get_screen_size(display)
@@ -525,10 +596,9 @@ def _capture_raw(display: str) -> tuple:
     draw = ImageDraw.Draw(img)
     draw.rectangle([(0, 0), (sw, 55)], fill=(30, 40, 80))
     draw.text((10, 10), f"⚠️ Screenshot failed — DISPLAY={display}", fill=(255, 120, 80))
-    draw.text((10, 32), "Methods: scrot, import, ffmpeg, xlib (3 attempts)", fill=(130, 130, 150))
+    draw.text((10, 32), "Methods: x11-stack, xwd+convert, pyscreenshot (3 attempts)", fill=(130, 130, 150))
     return img, sw or 1920, sh or 1080
 
-
 def _get_screen_size(display: str) -> tuple:
     try:
         r = subprocess.run(