pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/tray.py

@@ -0,0 +1,399 @@
+import os
+import sys
+import ctypes
+import threading
+import logging
+from typing import Callable, List, Optional
+from .utils import get_resource_path
+
+# Platform-specific imports
+if sys.platform == "win32":
+    import ctypes.wintypes
+    from .platforms.windows_ops.constants import NOTIFYICONDATAW
+
+# Windows Constants
+WM_USER = 0x0400
+WM_TRAYICON = WM_USER + 1
+NIM_ADD = 0x00
+NIM_MODIFY = 0x01
+NIM_DELETE = 0x02
+NIF_ICON = 0x01
+NIF_MESSAGE = 0x02
+NIF_TIP = 0x04
+NIF_INFO = 0x10
+WM_LBUTTONUP = 0x0202
+WM_RBUTTONUP = 0x0205
+WM_CONTEXTMENU = 0x007B
+TPM_LEFTALIGN = 0x0000
+TPM_RIGHTBUTTON = 0x0002
+MIIM_ID = 0x0002
+MIIM_TYPE = 0x0010
+MIIM_DATA = 0x0020
+MFT_STRING = 0x0000
+MFT_SEPARATOR = 0x0800
+
+
+class MenuItem:
+    def __init__(
+        self,
+        label: str,
+        callback: Optional[Callable] = None,
+        is_separator: bool = False,
+    ):
+        self.label = label
+        self.callback = callback
+        self.is_separator = is_separator
+        self.id = 0
+
+
+class SystemTray:
+    def __init__(self, title: str, icon_path: Optional[str] = None):
+        self.title = title
+        self.icon_path = icon_path
+        self.menu_items: List[MenuItem] = []
+        self.logger = logging.getLogger("Pytron.Tray")
+        self._hwnd = None
+        self._hicon = None
+        self._running = False
+        self._next_id = 1000
+        self._thread = None
+        self._app = None
+
+    def add_item(self, label: str, callback: Optional[Callable] = None):
+        item = MenuItem(label, callback)
+        item.id = self._next_id
+        self._next_id += 1
+        self.menu_items.append(item)
+        return self
+
+    def add_separator(self):
+        item = MenuItem("", is_separator=True)
+        self.menu_items.append(item)
+        return self
+
+    def add_quit_item(self, label: str = "Quit"):
+        """Adds a standard Quit item to the tray menu."""
+
+        def _quit():
+            if self._app:
+                # Use app.quit() for graceful exit (triggers cleanup/atexit)
+                self._app.quit()
+            else:
+                os._exit(0)
+
+        return self.add_item(label, _quit)
+
+    def start(self, app):
+        """Starts the tray icon."""
+        self._app = app
+        platform = sys.platform
+        if platform == "win32":
+            self._start_windows(app)
+        elif platform == "darwin":
+            self._start_darwin(app)
+        elif platform == "linux":
+            self._start_linux(app)
+        else:
+            self.logger.warning(f"System tray not implemented for {platform}")
+
+    def stop(self):
+        platform = sys.platform
+        if platform == "win32":
+            self._stop_windows()
+            # Cleanup Icon handle to prevent leaks
+            if self._hicon:
+                ctypes.windll.user32.DestroyIcon(self._hicon)
+                self._hicon = None
+
+    def _start_darwin(self, app):
+        try:
+            from AppKit import (
+                NSStatusBar,
+                NSVariableStatusItemLength,
+                NSMenu,
+                NSMenuItem,
+                NSImage,
+            )
+
+            self._status_item = NSStatusBar.systemStatusBar().statusItemWithLength_(
+                NSVariableStatusItemLength
+            )
+            self._status_item.setToolTip_(self.title)
+
+            if self.icon_path:
+                image = NSImage.alloc().initWithContentsOfFile_(self.icon_path)
+                if image:
+                    image.setTemplate_(True)
+                    self._status_item.button().setImage_(image)
+
+            if not self._status_item.button().image():
+                self._status_item.setTitle_(self.title[:3])
+
+            # Create Menu
+            menu = NSMenu.alloc().init()
+
+            class MenuDelegate:
+                def __init__(self, callback):
+                    self.callback = callback
+
+                def call_(self, sender):
+                    if self.callback:
+                        self.callback()
+
+            self._delegates = []
+
+            for item in self.menu_items:
+                if item.is_separator:
+                    menu.addItem_(NSMenuItem.separatorItem())
+                else:
+                    d = MenuDelegate(item.callback)
+                    self._delegates.append(d)
+                    mi = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
+                        item.label, "call:", ""
+                    )
+                    mi.setTarget_(d)
+                    menu.addItem_(mi)
+
+            self._status_item.setMenu_(menu)
+        except ImportError:
+            self.logger.error("macOS Tray requires 'pyobjc-framework-Cocoa'.")
+
+    def _start_linux(self, app):
+        try:
+            import gi
+
+            gi.require_version("Gtk", "3.0")
+            gi.require_version("AppIndicator3", "0.1")
+            from gi.repository import Gtk, AppIndicator3
+
+            ind_id = f"pytron.tray.{id(self)}"
+            icon = self.icon_path if self.icon_path else "help-about"
+
+            indicator = AppIndicator3.Indicator.new(
+                ind_id, icon, AppIndicator3.IndicatorCategory.APPLICATION_STATUS
+            )
+            indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+
+            menu = Gtk.Menu()
+
+            for item in self.menu_items:
+                if item.is_separator:
+                    menu.append(Gtk.SeparatorMenuItem())
+                else:
+                    mi = Gtk.MenuItem(label=item.label)
+                    if item.callback:
+                        mi.connect("activate", lambda _: item.callback())
+                    menu.append(mi)
+
+            menu.show_all()
+            indicator.set_menu(menu)
+            self._indicator = indicator
+
+        except (ImportError, ValueError):
+            self.logger.error("Linux Tray requires 'PyGObject' and 'libappindicator3'.")
+
+    def _start_windows(self, app):
+        # Event to sync creation
+        ready_event = threading.Event()
+
+        def run_tray_thread():
+            user32 = ctypes.windll.user32
+            kernel32 = ctypes.windll.kernel32
+            shell32 = ctypes.windll.shell32
+
+            # --- Definitions ---
+            user32.DefWindowProcW.argtypes = [
+                ctypes.wintypes.HWND,
+                ctypes.wintypes.UINT,
+                ctypes.wintypes.WPARAM,
+                ctypes.wintypes.LPARAM,
+            ]
+            user32.DefWindowProcW.restype = ctypes.wintypes.LPARAM
+            user32.CreateWindowExW.argtypes = [
+                ctypes.c_uint,
+                ctypes.c_wchar_p,
+                ctypes.c_wchar_p,
+                ctypes.c_uint,
+                ctypes.c_int,
+                ctypes.c_int,
+                ctypes.c_int,
+                ctypes.c_int,
+                ctypes.c_void_p,
+                ctypes.c_void_p,
+                ctypes.c_void_p,
+                ctypes.c_void_p,
+            ]
+            user32.CreateWindowExW.restype = ctypes.c_void_p
+            kernel32.GetModuleHandleW.restype = ctypes.c_void_p
+
+            # Ensure we use the shared NOTIFYICONDATAW definition
+            shell32.Shell_NotifyIconW.argtypes = [
+                ctypes.c_ulong,
+                ctypes.POINTER(NOTIFYICONDATAW),
+            ]
+            shell32.Shell_NotifyIconW.restype = ctypes.wintypes.BOOL
+
+            def window_proc(hwnd, msg, wparam, lparam):
+                if msg == WM_TRAYICON:
+                    if lparam == WM_LBUTTONUP:
+                        app.show()
+                    elif lparam == WM_RBUTTONUP:
+                        self._show_menu(hwnd)
+                elif msg == 0x0111:  # WM_COMMAND
+                    item_id = wparam & 0xFFFF
+                    for item in self.menu_items:
+                        if item.id == item_id and item.callback:
+                            try:
+                                item.callback()
+                            except Exception as e:
+                                self.logger.error(f"Menu callback failed: {e}")
+                            break
+                return user32.DefWindowProcW(hwnd, msg, wparam, lparam)
+
+            WNDPROC = ctypes.WINFUNCTYPE(
+                ctypes.wintypes.LPARAM,
+                ctypes.wintypes.HWND,
+                ctypes.wintypes.UINT,
+                ctypes.wintypes.WPARAM,
+                ctypes.wintypes.LPARAM,
+            )
+            self._wndproc = WNDPROC(window_proc)  # Keep ref to prevent GC
+
+            class WNDCLASSW(ctypes.Structure):
+                _fields_ = [
+                    ("style", ctypes.c_uint),
+                    ("lpfnWndProc", WNDPROC),
+                    ("cbClsExtra", ctypes.c_int),
+                    ("cbWndExtra", ctypes.c_int),
+                    ("hInstance", ctypes.c_void_p),
+                    ("hIcon", ctypes.c_void_p),
+                    ("hCursor", ctypes.c_void_p),
+                    ("hbrBackground", ctypes.c_void_p),
+                    ("lpszMenuName", ctypes.c_wchar_p),
+                    ("lpszClassName", ctypes.c_wchar_p),
+                ]
+
+            wc = WNDCLASSW()
+            wc.lpfnWndProc = self._wndproc
+            wc.lpszClassName = f"PytronTray_{id(self)}"
+            wc.hInstance = kernel32.GetModuleHandleW(None)
+            user32.RegisterClassW(ctypes.byref(wc))
+
+            # 2. Create Window INSIDE this thread
+            self._hwnd = user32.CreateWindowExW(
+                0, wc.lpszClassName, self.title, 0, 0, 0, 0, 0, 0, 0, wc.hInstance, 0
+            )
+
+            # 3. Create Icon
+            if self.icon_path:
+                IMAGE_ICON = 1
+                LR_LOADFROMFILE = 0x00000010
+                r_path = get_resource_path(self.icon_path)
+                self.logger.debug(f"Attempting to load icon from: {r_path}")
+
+                # Load 16x16 for logic
+                self._hicon = user32.LoadImageW(
+                    None, str(r_path), IMAGE_ICON, 16, 16, LR_LOADFROMFILE
+                )
+
+                if not self._hicon:
+                    err = ctypes.GetLastError()
+                    self.logger.warning(
+                        f"Failed to load 16x16 icon. Error: {err}. Retrying with default size."
+                    )
+                    # Retry with default size
+                    self._hicon = user32.LoadImageW(
+                        None, str(r_path), IMAGE_ICON, 0, 0, LR_LOADFROMFILE
+                    )
+                    if not self._hicon:
+                        self.logger.error(
+                            f"Failed to load default size icon. Error: {ctypes.GetLastError()}"
+                        )
+
+            if not self._hicon:
+                self.logger.warning("Fallback to system application icon")
+                self._hicon = user32.LoadIconW(0, ctypes.c_void_p(32512))
+
+            # 4. Add to Tray
+            nid = NOTIFYICONDATAW()
+            nid.cbSize = ctypes.sizeof(NOTIFYICONDATAW)
+            nid.hWnd = self._hwnd
+            nid.uID = 1
+            nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP
+            nid.uCallbackMessage = WM_TRAYICON
+            nid.hIcon = self._hicon
+            nid.szTip = self.title[:127]
+
+            shell32.Shell_NotifyIconW(NIM_ADD, ctypes.byref(nid))
+
+            # Signal that we are ready!
+            ready_event.set()
+
+            # 5. Pump Messages (Blocking)
+            msg = ctypes.wintypes.MSG()
+            while self._running:
+                # GetMessage blocks until a message arrives
+                res = user32.GetMessageW(ctypes.byref(msg), 0, 0, 0)
+                if res <= 0:
+                    break
+                user32.TranslateMessage(ctypes.byref(msg))
+                user32.DispatchMessageW(ctypes.byref(msg))
+
+            # Cleanup when loop exits
+            if self._hwnd:
+                user32.DestroyWindow(self._hwnd)
+
+        self._running = True
+        self._thread = threading.Thread(target=run_tray_thread, daemon=True)
+        self._thread.start()
+
+        # Wait for tray to appear before returning (prevents race conditions)
+        ready_event.wait(timeout=2.0)
+
+    def _show_menu(self, hwnd):
+        hmenu = ctypes.windll.user32.CreatePopupMenu()
+
+        for item in self.menu_items:
+            if item.is_separator:
+                ctypes.windll.user32.AppendMenuW(hmenu, MFT_SEPARATOR, 0, None)
+            else:
+                ctypes.windll.user32.AppendMenuW(hmenu, MFT_STRING, item.id, item.label)
+
+        pos = ctypes.wintypes.POINT()
+        ctypes.windll.user32.GetCursorPos(ctypes.byref(pos))
+
+        ctypes.windll.user32.SetForegroundWindow(hwnd)
+        ctypes.windll.user32.TrackPopupMenu(
+            hmenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pos.x, pos.y, 0, hwnd, None
+        )
+        ctypes.windll.user32.PostMessageW(hwnd, 0, 0, 0)
+
+    def _stop_windows(self):
+        self._running = False
+        if self._hwnd:
+            # Force wake up the message loop to exit?
+            # GetMessage is blocking. We need to post a dummy message or WM_NULL/WM_CLOSE
+            ctypes.windll.user32.PostMessageW(self._hwnd, 0x0010, 0, 0)  # WM_CLOSE
+
+        # Wait for thread to finish to prevent zombies
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=2.0)
+            if self._thread.is_alive():
+                self.logger.warning("Tray thread did not exit cleanly.")
+
+        # Also delete icon
+        if self._hwnd:
+            nid = NOTIFYICONDATAW()
+            nid.cbSize = ctypes.sizeof(NOTIFYICONDATAW)
+            nid.hWnd = self._hwnd
+            nid.uID = 1
+
+            shell32 = ctypes.windll.shell32
+            # Use strict argtypes with shared structure
+            shell32.Shell_NotifyIconW.argtypes = [
+                ctypes.c_ulong,
+                ctypes.POINTER(NOTIFYICONDATAW),
+            ]
+
+            shell32.Shell_NotifyIconW(NIM_DELETE, ctypes.byref(nid))
+            self._hwnd = None

pytron/updater.py

@@ -0,0 +1,181 @@
+import os
+import sys
+import json
+import urllib.request
+import urllib.error
+import subprocess
+import tempfile
+import logging
+from pathlib import Path
+from packaging.version import parse as parse_version
+import stat
+
+
+class Updater:
+    def __init__(self, current_version=None):
+        self.logger = logging.getLogger("Pytron.Updater")
+        # Try to infer version if not provided
+        self.current_version = current_version
+        if not self.current_version:
+            try:
+                # If running from source/pytron structure
+                from . import __version__
+
+                self.current_version = __version__
+            except ImportError:
+                self.current_version = "0.0.0"
+
+        # In a real app, the developer sets the version in settings.json or passes it.
+        # We will try to find the app's version from settings.json if it exists nearby
+        try:
+            settings_path = Path("settings.json")
+            if settings_path.exists():
+                data = json.loads(settings_path.read_text())
+                if "version" in data:
+                    self.current_version = data["version"]
+        except:
+            pass
+
+    def check(self, url: str) -> dict | None:
+        """
+        Checks for updates at the given URL.
+        """
+        if not getattr(sys, "frozen", False):
+            self.logger.debug("Skipping update check in development mode.")
+            return None
+        self.logger.info(f"Checking for updates at {url}...")
+        try:
+            if not url.startswith("https://"):
+                raise ValueError("Updater only supports HTTPS")
+
+            # nosemgrep
+            with urllib.request.urlopen(url, timeout=5) as response:  # nosec B310
+                data = json.loads(response.read().decode())
+                remote_version = data.get("version")
+
+                if not remote_version:
+                    self.logger.error("Invalid update manifest: missing 'version'")
+                    return None
+
+                # Compare versions
+                if parse_version(remote_version) > parse_version(self.current_version):
+                    self.logger.info(
+                        f"Update available: {remote_version} (Current: {self.current_version})"
+                    )
+                    return data
+                else:
+                    self.logger.info("App is up to date.")
+                    return None
+
+        except urllib.error.URLError as e:
+            self.logger.error(f"Failed to check for updates: {e}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error checking updates: {e}")
+            return None
+
+    def download_and_install(self, update_info: dict, on_progress=None):
+        """
+        Downloads the update.
+        In Secure Builds, it prefers the 'patch_url' to download a tiny evolution patch.
+        Otherwise, it downloads the full installer.
+        """
+        patch_url = update_info.get("patch_url")
+        full_url = update_info.get("url")
+
+        # Detect if we are in a Secure Build (app.pytron exists next to EXE)
+        is_secure = False
+        if getattr(sys, "frozen", False):
+            # Real app root is parent of _internal or where exe is
+            exe_dir = Path(sys.executable).parent
+            payload_path = exe_dir / "app.pytron"
+            if payload_path.exists():
+                is_secure = True
+                self.logger.info("Secure Build detected. Ready for binary evolution.")
+
+        # If secure and patch exists, use patch
+        if is_secure and patch_url:
+            self.logger.info(f"Preferring evolution patch: {patch_url}")
+            return self._handle_patch_download(patch_url, on_progress)
+
+        if not full_url:
+            self.logger.error("No download URL provided in update info.")
+            return False
+
+        return self._handle_full_download(full_url, on_progress)
+
+    def _handle_patch_download(self, url, on_progress):
+        try:
+            exe_dir = Path(sys.executable).parent
+            patch_dest = exe_dir / "app.pytron_patch"
+
+            self.logger.info(f"Downloading patch to {patch_dest}...")
+
+            def progress(block_num, block_size, total_size):
+                if on_progress:
+                    downloaded = block_num * block_size
+                    percent = min(100, int((downloaded / total_size) * 100))
+                    on_progress(percent)
+
+            # nosemgrep
+            urllib.request.urlretrieve(
+                url, patch_dest, reporthook=progress
+            )  # nosec B310
+            self.logger.info("Evolution patch downloaded successfully.")
+
+            # Since the Rust loader handles patching on launch, we just need to restart
+            self.logger.info("Restarting to apply evolution...")
+
+            if sys.platform == "win32":
+                subprocess.Popen(
+                    [sys.executable], shell=False, creationflags=0x00000008
+                )  # DETACHED_PROCESS # nosec B603
+            else:
+                subprocess.Popen([sys.executable])  # nosec B603
+
+            sys.exit(0)
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to download patch: {e}")
+            return False
+
+    def _handle_full_download(self, url, on_progress):
+        filename = url.split("/")[-1]
+        if not filename.endswith(
+            (".exe", ".msi", ".dmg", ".pkg", ".deb", ".rpm", ".AppImage")
+        ):
+            filename = (
+                "update_installer.exe"
+                if sys.platform == "win32"
+                else "update_installer"
+            )
+
+        download_path = Path(tempfile.gettempdir()) / filename
+        try:
+
+            def progress(block_num, block_size, total_size):
+                if on_progress:
+                    percent = min(100, int((block_num * block_size / total_size) * 100))
+                    on_progress(percent)
+
+            # nosemgrep
+            urllib.request.urlretrieve(
+                url, download_path, reporthook=progress
+            )  # nosec B310
+            self.logger.info(f"Download complete: {download_path}")
+
+            if sys.platform == "win32":
+                subprocess.Popen(
+                    [str(download_path)], shell=False, creationflags=0x00000008
+                )
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", str(download_path)])
+            else:
+                os.chmod(download_path, stat.S_IRWXU)
+                subprocess.Popen([str(download_path)])
+
+            sys.exit(0)
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to install full update: {e}")
+            return False

pytron/utf8_hook.py

@@ -0,0 +1,112 @@
+"""Runtime hook for Pytron.
+
+This hook attempts to make a frozen Pytron app robust when printing or logging
+modern Unicode (emoji, CJK, astral-plane characters) on Windows and other
+platforms. It is best-effort and will not crash the application if any step
+fails.
+"""
+
+import os
+import sys
+import io
+import locale
+import logging
+
+
+def _set_utf8_mode():
+    # Best-effort environment hints for subprocesses and libraries
+    try:
+        os.environ.setdefault("PYTHONUTF8", "1")
+        os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+        os.environ.setdefault("LANG", "en_US.UTF-8")
+    except Exception:
+        pass
+
+    # Prefer the user's locale if possible (no-op on failure)
+    try:
+        locale.setlocale(locale.LC_ALL, "")
+    except Exception:
+        pass
+
+    # Override locale.getpreferredencoding() to return utf-8 so libraries
+    # that consult it will prefer UTF-8.
+    try:
+        import locale as _locale
+
+        _locale.getpreferredencoding = lambda do_setlocale=False: "utf-8"
+    except Exception:
+        pass
+
+    # On Windows try to set the console code page to UTF-8 (65001).
+    if sys.platform.startswith("win"):
+        try:
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+
+            # Harden: Explicitly define signatures for robustness
+            kernel32.SetConsoleOutputCP.argtypes = [ctypes.c_uint]
+            kernel32.SetConsoleOutputCP.restype = ctypes.c_int
+
+            kernel32.SetConsoleCP.argtypes = [ctypes.c_uint]
+            kernel32.SetConsoleCP.restype = ctypes.c_int
+
+            # Check return values (Non-zero is success)
+            if kernel32.SetConsoleOutputCP(65001) == 0:
+                # logging.warning(f"Failed to SetConsoleOutputCP: {err}")
+                pass
+
+            if kernel32.SetConsoleCP(65001) == 0:
+                pass
+
+        except Exception:
+            pass
+
+    # Wrap or reconfigure stdio streams to UTF-8 with surrogatepass to avoid
+    # raising UnicodeEncodeError when printing characters that the system
+    # code page cannot represent.
+    def wrap_stream(stream):
+        try:
+            buf = getattr(stream, "buffer", None)
+            if buf is not None:
+                return io.TextIOWrapper(
+                    buf, encoding="utf-8", errors="surrogatepass", line_buffering=True
+                )
+            # Fallback: try reconfigure (Python 3.7+)
+            try:
+                stream.reconfigure(encoding="utf-8", errors="surrogatepass")
+            except Exception:
+                pass
+        except Exception:
+            pass
+        return stream
+
+    try:
+        if sys.stdin is not None:
+            sys.stdin = wrap_stream(sys.stdin)
+        if sys.stdout is not None:
+            sys.stdout = wrap_stream(sys.stdout)
+        if sys.stderr is not None:
+            sys.stderr = wrap_stream(sys.stderr)
+    except Exception:
+        pass
+
+    # Patch logging.StreamHandler so that handlers created after this hook will
+    # get their stream wrapped as well.
+    try:
+        _orig_init = logging.StreamHandler.__init__
+
+        def _patched_init(self, stream=None):
+            _orig_init(self, stream=stream)
+            try:
+                if getattr(self, "stream", None) is not None:
+                    self.stream = wrap_stream(self.stream)
+            except Exception:
+                pass
+
+        logging.StreamHandler.__init__ = _patched_init
+    except Exception:
+        pass
+
+
+_set_utf8_mode()