pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/platforms/darwin.py

@@ -0,0 +1,82 @@
+from .interface import PlatformInterface
+from .darwin_ops import window, system, libs
+
+
+class DarwinImplementation(PlatformInterface):
+    def __init__(self):
+        # Libraries are loaded by darwin_ops.libs on import
+        if not libs.objc:
+            print("Pytron Warning: Cocoa/ObjC not found.")
+
+    def minimize(self, w):
+        window.minimize(w)
+
+    def center(self, w):
+        window.center(w)
+
+    def set_bounds(self, w, x, y, width, height):
+        window.set_bounds(w, x, y, width, height)
+
+    def close(self, w):
+        window.close(w)
+
+    def toggle_maximize(self, w):
+        return window.toggle_maximize(w)
+
+    def make_frameless(self, w):
+        window.make_frameless(w)
+
+    def start_drag(self, w):
+        window.start_drag(w)
+
+    def message_box(self, w, title, message, style=0):
+        return system.message_box(w, title, message, style)
+
+    def hide(self, w):
+        window.hide(w)
+
+    def is_visible(self, w):
+        return window.is_visible(w)
+
+    def is_alive(self, w):
+        # On macOS/Cocoa, we check if the NSWindow pointer is still valid
+        win = window.get_window(w)
+        return bool(win and win != 0)
+
+    def show(self, w):
+        window.show(w)
+
+    def set_fullscreen(self, w, fullscreen):
+        window.set_fullscreen(w, fullscreen)
+
+    def set_always_on_top(self, w, enable):
+        window.set_always_on_top(w, enable)
+
+    def notification(self, w, title, message, icon=None):
+        system.notification(w, title, message, icon)
+
+    def open_file_dialog(self, w, title, default_path=None, file_types=None):
+        return system.open_file_dialog(w, title, default_path, file_types)
+
+    def save_file_dialog(
+        self, w, title, default_path=None, default_name=None, file_types=None
+    ):
+        return system.save_file_dialog(w, title, default_path, default_name, file_types)
+
+    def open_folder_dialog(self, w, title, default_path=None):
+        return system.open_folder_dialog(w, title, default_path)
+
+    def set_taskbar_progress(self, w, state="normal", value=0, max_value=100):
+        system.set_taskbar_progress(w, state, value, max_value)
+
+    def set_window_icon(self, w, icon_path):
+        window.set_window_icon(w, icon_path)
+
+    def set_app_id(self, app_id):
+        system.set_app_id(app_id)
+
+    def set_launch_on_boot(self, app_name, exe_path, enable=True):
+        return system.set_launch_on_boot(app_name, exe_path, enable)
+
+    def register_protocol(self, scheme):
+        return system.register_protocol(scheme)

pytron/platforms/darwin_ops/libs.py

@@ -0,0 +1,31 @@
+import ctypes
+import ctypes.util
+
+cocoa = None
+objc = None
+
+
+def load_libs():
+    global cocoa, objc
+    try:
+        # Load Cocoa
+        cocoa = ctypes.cdll.LoadLibrary(ctypes.util.find_library("Cocoa"))
+
+        # Setup objc_msgSend
+        objc = ctypes.cdll.LoadLibrary(ctypes.util.find_library("objc"))
+
+        objc.objc_getClass.restype = ctypes.c_void_p
+        objc.objc_getClass.argtypes = [ctypes.c_char_p]
+
+        objc.sel_registerName.restype = ctypes.c_void_p
+        objc.sel_registerName.argtypes = [ctypes.c_char_p]
+
+        # Do NOT set restype/argtypes for objc_msgSend here.
+        # It MUST be cast to the correct signature for every call on ARM64.
+
+    except Exception as e:
+        print(f"Pytron Warning: Cocoa/ObjC not found: {e}")
+        objc = None
+
+
+load_libs()

pytron/platforms/darwin_ops/system.py

@@ -0,0 +1,182 @@
+import subprocess
+import os
+import ctypes
+from . import libs
+from .utils import get_class, str_to_nsstring, msg_send, call
+
+
+def message_box(w, title, message, style=0):
+    # Use osascript for native-look dialogs
+    script = ""
+    if style == 4:
+        script = f'display alert "{title}" message "{message}" buttons {{"No", "Yes"}} default button "Yes"'
+    elif style == 1:
+        script = f'display alert "{title}" message "{message}" buttons {{"Cancel", "OK"}} default button "OK"'
+    else:
+        script = f'display alert "{title}" message "{message}" buttons {{"OK"}} default button "OK"'
+
+    try:
+        output = subprocess.check_output(["osascript", "-e", script], text=True)
+        if "Yes" in output or "OK" in output:
+            return 6 if style == 4 else 1
+        return 7 if style == 4 else 2
+    except subprocess.CalledProcessError:
+        return 7 if style == 4 else 2
+    except Exception:
+        return 6
+
+
+def notification(w, title, message, icon=None):
+    script = f'display notification "{message}" with title "{title}"'
+    try:
+        subprocess.Popen(["osascript", "-e", script])
+    except Exception:
+        pass
+
+
+def _run_osascript_dialog(script):
+    try:
+        proc = subprocess.run(
+            ["osascript", "-e", script], capture_output=True, text=True
+        )
+        if proc.returncode == 0:
+            return proc.stdout.strip()
+        return None
+    except Exception:
+        return None
+
+
+def open_file_dialog(w, title, default_path=None, file_types=None):
+    script = f'POSIX path of (choose file with prompt "{title}"'
+    if default_path:
+        script += f' default location "{default_path}"'
+    script += ")"
+    return _run_osascript_dialog(script)
+
+
+def save_file_dialog(w, title, default_path=None, default_name=None, file_types=None):
+    script = f'POSIX path of (choose file name with prompt "{title}"'
+    if default_path:
+        script += f' default location "{default_path}"'
+    if default_name:
+        script += f' default name "{default_name}"'
+    script += ")"
+    return _run_osascript_dialog(script)
+
+
+def open_folder_dialog(w, title, default_path=None):
+    script = f'POSIX path of (choose folder with prompt "{title}"'
+    if default_path:
+        script += f' default location "{default_path}"'
+    script += ")"
+    return _run_osascript_dialog(script)
+
+
+def set_app_id(app_id):
+    if not libs.objc:
+        return
+    try:
+        cls_proc = get_class("NSProcessInfo")
+        proc_info = msg_send(cls_proc, "processInfo")
+
+        name_str = str_to_nsstring(app_id)
+        msg_send(proc_info, "setProcessName:", name_str)
+    except Exception:
+        pass
+
+
+def set_launch_on_boot(app_name, exe_path, enable=True):
+    import shlex
+
+    home = os.path.expanduser("~")
+    launch_agents = os.path.join(home, "Library/LaunchAgents")
+    plist_file = os.path.join(launch_agents, f"com.{app_name.lower()}.startup.plist")
+
+    if enable:
+        try:
+            os.makedirs(launch_agents, exist_ok=True)
+            args = shlex.split(exe_path)
+            array_str = "\n".join([f"    <string>{a}</string>" for a in args])
+            content = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.{app_name.lower()}.startup</string>
+    <key>ProgramArguments</key>
+    <array>
+{array_str}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+</dict>
+</plist>
+"""
+            with open(plist_file, "w") as f:
+                f.write(content)
+            return True
+        except Exception as e:
+            print(f"[Pytron] Failed to enable launch agent on macOS: {e}")
+            return False
+    else:
+        try:
+            if os.path.exists(plist_file):
+                os.remove(plist_file)
+            return True
+        except Exception as e:
+            print(f"[Pytron] Failed to disable launch agent on macOS: {e}")
+            return False
+
+
+def set_taskbar_progress(w, state="normal", value=0, max_value=100):
+    if not libs.objc:
+        return
+    try:
+        cls_app = get_class("NSApplication")
+        ns_app = msg_send(cls_app, "sharedApplication")
+        dock_tile = msg_send(ns_app, "dockTile")
+
+        badge_text = None
+        if state in ("normal", "error", "paused") and max_value > 0:
+            pct = int((value / max_value) * 100)
+            badge_text = str_to_nsstring(f"{pct}%")
+        elif state == "indeterminate":
+            badge_text = str_to_nsstring("...")
+
+        msg_send(dock_tile, "setBadgeLabel:", badge_text)
+        msg_send(dock_tile, "display")
+
+    except Exception:
+        pass
+
+
+def register_protocol(scheme):
+    """
+    Registers the application to handle a custom URI scheme on macOS.
+    Note: On macOS, this is primarily handled via the Info.plist CFBundleURLTypes.
+    This method attempts to refresh the Launch Services database if bundled.
+    """
+    try:
+        import sys
+
+        if getattr(sys, "frozen", False):
+            # Try to find the .app bundle path
+            exec_path = sys.executable
+            if ".app/Contents/MacOS/" in exec_path:
+                app_path = exec_path.split(".app/Contents/MacOS/")[0] + ".app"
+                # Use lsregister to refresh the registration
+                lsregister_path = "/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister"
+                if os.path.exists(lsregister_path):
+                    subprocess.run(
+                        [lsregister_path, "-f", app_path], capture_output=True
+                    )
+                    return True
+
+        # If not bundled or lsregister failed
+        print(
+            f"[Pytron] Warning: For {scheme}:// to work on macOS, the application should be bundled as a .app with the scheme defined in Info.plist."
+        )
+        return False
+    except Exception as e:
+        print(f"[Pytron] macOS Protocol Registration Error: {e}")
+        return False

pytron/platforms/darwin_ops/utils.py

@@ -0,0 +1,85 @@
+import ctypes
+from . import libs
+
+# In Native Engine architecture, 'w' is passed as the NSWindow pointer/integer directly.
+
+
+def get_window(w):
+    return w
+
+
+get_hwnd = get_window
+
+
+def msg_send(target, selector, *args, restype=ctypes.c_void_p, argtypes=None):
+    if not libs.objc:
+        return None
+
+    # Safety: If we are in a test environment with Mocks, avoid CFUNCTYPE casting
+    # on the mock as it can cause infinite recursion during internal ctypes inspection.
+    from unittest.mock import Mock
+
+    if isinstance(libs.objc, Mock):
+        # In mock mode, just call directly to record the call
+        # and ensure sel_registerName is called so tests pass.
+        sel = libs.objc.sel_registerName(selector.encode("utf-8"))
+        return libs.objc.objc_msgSend(target, sel, *args)
+
+    # On macOS ARM64, objc_msgSend MUST be cast to the correct function pointer type
+    # before being called, or it will cause a segmentation fault.
+    if argtypes is None:
+        # Infer from args
+        argtypes = []
+        for x in args:
+            if isinstance(x, (int, float, bool)):
+                if isinstance(x, bool):
+                    argtypes.append(ctypes.c_bool)
+                elif isinstance(x, float):
+                    argtypes.append(ctypes.c_double)
+                else:
+                    argtypes.append(ctypes.c_void_p)
+            else:
+                argtypes.append(ctypes.c_void_p)
+
+    all_argtypes = [ctypes.c_void_p, ctypes.c_void_p] + list(argtypes)
+
+    # We must ensure we are using the raw function pointer without restype/argtypes
+    # already set on it, as that can interfere with CFUNCTYPE.
+    try:
+        # Get the underlying function pointer address
+        func_addr = ctypes.cast(libs.objc.objc_msgSend, ctypes.c_void_p).value
+        proto = ctypes.CFUNCTYPE(restype, *all_argtypes)
+        f = proto(func_addr)
+    except Exception:
+        # Fallback to direct call if casting fails (though this may crash on ARM64)
+        f = libs.objc.objc_msgSend
+
+    sel = libs.objc.sel_registerName(selector.encode("utf-8"))
+    return f(target, sel, *args)
+
+
+def call(obj, selector, *args):
+    # Backward compatible call - defaults to void_p return
+    return msg_send(obj, selector, *args)
+
+
+def get_class(name):
+    if not libs.objc:
+        return None
+    return libs.objc.objc_getClass(name.encode("utf-8"))
+
+
+def str_to_nsstring(s):
+    if not libs.objc:
+        return None
+    cls = get_class("NSString")
+    return msg_send(
+        cls, "stringWithUTF8String:", s.encode("utf-8"), argtypes=[ctypes.c_char_p]
+    )
+
+
+def bool_to_nsnumber(b):
+    if not libs.objc:
+        return None
+    cls = get_class("NSNumber")
+    return msg_send(cls, "numberWithBool:", b, argtypes=[ctypes.c_bool])

pytron/platforms/darwin_ops/webview.py

@@ -0,0 +1,5 @@
+def register_pytron_scheme(w, callback):
+    """
+    Deprecated: Using JS-Bridge Interceptor in webview.py for cross-platform stability.
+    """
+    return None

pytron/platforms/darwin_ops/window.py

@@ -0,0 +1,102 @@
+import ctypes
+from . import libs
+from .utils import get_window, call, get_class, str_to_nsstring, msg_send
+
+
+def minimize(w):
+    win = get_window(w)
+    call(win, "miniaturize:", None)
+
+
+def set_bounds(w, x, y, width, height):
+    pass
+
+
+def close(w):
+    win = get_window(w)
+    call(win, "close")
+
+
+def toggle_maximize(w):
+    win = get_window(w)
+    call(win, "zoom:", None)
+    return True
+
+
+def make_frameless(w):
+    win = get_window(w)
+    # NSWindowStyleMaskTitled = 1 << 0
+    # NSWindowStyleMaskClosable = 1 << 1
+    # NSWindowStyleMaskMiniaturizable = 1 << 2
+    # NSWindowStyleMaskResizable = 1 << 3
+    # NSWindowStyleMaskFullSizeContentView = 1 << 15
+
+    # We want bits: 1|2|4|8|32768 = 32783
+    call(win, "setStyleMask:", 32783)  # Standard macos "frameless but native controls"
+    call(win, "setTitlebarAppearsTransparent:", 1)
+    call(win, "setTitleVisibility:", 1)  # NSWindowTitleHidden
+
+
+def start_drag(w):
+    win = get_window(w)
+    call(win, "setMovableByWindowBackground:", 1)
+
+
+def hide(w):
+    win = get_window(w)
+    call(win, "orderOut:", None)
+
+
+def is_visible(w):
+    win = get_window(w)
+    return bool(call(win, "isVisible"))
+
+
+def show(w):
+    win = get_window(w)
+    call(win, "makeKeyAndOrderFront:", None)
+    try:
+        cls_app = get_class("NSApplication")
+        ns_app = msg_send(cls_app, "sharedApplication")
+        msg_send(ns_app, "activateIgnoringOtherApps:", True)
+    except Exception:
+        pass
+
+
+def set_window_icon(w, icon_path):
+    if not libs.objc or not icon_path:
+        return
+    try:
+        cls_image = get_class("NSImage")
+        img_alloc = msg_send(cls_image, "alloc")
+        ns_path = str_to_nsstring(icon_path)
+        ns_image = msg_send(img_alloc, "initWithContentsOfFile:", ns_path)
+
+        if ns_image:
+            cls_app = get_class("NSApplication")
+            ns_app = msg_send(cls_app, "sharedApplication")
+            msg_send(ns_app, "setApplicationIconImage:", ns_image)
+    except Exception:
+        pass
+
+
+def center(w):
+    win = get_window(w)
+    call(win, "center")
+
+
+def set_always_on_top(w, enable):
+    win = get_window(w)
+    # NSFloatingWindowLevel = 3, NSNormalWindowLevel = 0
+    level = 3 if enable else 0
+    call(win, "setLevel:", level)
+
+
+def set_fullscreen(w, enable):
+    win = get_window(w)
+    # Check current style mask for NSWindowStyleMaskFullScreen (1 << 14)
+    style_mask = call(win, "styleMask")
+    is_fullscreen = (style_mask & (1 << 14)) != 0
+
+    if is_fullscreen != enable:
+        call(win, "toggleFullScreen:", None)

pytron/platforms/interface.py

@@ -0,0 +1,152 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, List, TypeAlias
+
+# Defines a "Handle" type for clarity -> Zero runtime cost, high readability.
+WindowHandle: TypeAlias = int
+
+
+class PlatformInterface(ABC):
+    """
+    PINNED STABILITY CONTRACT
+    -------------------------
+    This interface defines the immutable core contract for all platform implementations.
+    Core lifecycle and window operations are abstract and MUST be implemented.
+    Extended capabilities (Notifications, Taskbar, etc.) are virtual and optional.
+    """
+
+    # --- Core Window Operations (Pinned) ---
+
+    @abstractmethod
+    def show(self, w: WindowHandle) -> None:
+        pass
+
+    @abstractmethod
+    def hide(self, w: WindowHandle) -> None:
+        pass
+
+    @abstractmethod
+    def close(self, w: WindowHandle) -> None:
+        pass
+
+    @abstractmethod
+    def minimize(self, w: WindowHandle) -> None:
+        pass
+
+    @abstractmethod
+    def toggle_maximize(self, w: WindowHandle) -> bool:
+        """Returns True if maximized, False if restored."""
+        pass
+
+    @abstractmethod
+    def set_bounds(
+        self, w: WindowHandle, x: int, y: int, width: int, height: int
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def set_fullscreen(self, w: WindowHandle, fullscreen: bool) -> None:
+        pass
+
+    @abstractmethod
+    def set_always_on_top(self, w: WindowHandle, enable: bool) -> None:
+        pass
+
+    @abstractmethod
+    def is_visible(self, w: WindowHandle) -> bool:
+        pass
+
+    @abstractmethod
+    def center(self, w: WindowHandle) -> None:
+        pass
+
+    # --- Essential extensions (Should interpret 'w') ---
+
+    def is_alive(self, w: WindowHandle) -> bool:
+        """Checks if the native window handle is still valid. Default True to prevent crashes."""
+        return True
+
+    def make_frameless(self, w: WindowHandle) -> None:
+        pass
+
+    def start_drag(self, w: WindowHandle) -> None:
+        pass
+
+    def set_window_icon(self, w: WindowHandle, icon_path: str) -> None:
+        pass
+
+    def set_menu(self, w: WindowHandle, menu_bar: List) -> None:
+        pass
+
+    # --- System Dialogs & Interactions (Stable Extensions) ---
+
+    def message_box(
+        self, w: WindowHandle, title: str, message: str, style: int = 0
+    ) -> int:
+        return 0  # Default OK/Cancel result
+
+    def open_file_dialog(
+        self,
+        w: WindowHandle,
+        title: str,
+        default_path: Optional[str] = None,
+        file_types: Optional[str] = None,
+    ) -> Optional[str]:
+        return None
+
+    def save_file_dialog(
+        self,
+        w: WindowHandle,
+        title: str,
+        default_path: Optional[str] = None,
+        default_name: Optional[str] = None,
+        file_types: Optional[str] = None,
+    ) -> Optional[str]:
+        return None
+
+    def open_folder_dialog(
+        self, w: WindowHandle, title: str, default_path: Optional[str] = None
+    ) -> Optional[str]:
+        return None
+
+    def notification(
+        self, w: WindowHandle, title: str, message: str, icon: Optional[str] = None
+    ) -> None:
+        pass
+
+    def set_taskbar_progress(
+        self, w: WindowHandle, state: str, value: int, max_value: int
+    ) -> None:
+        """
+        Sets the taskbar/dock progress bar state.
+        state: 'normal', 'error', 'paused', 'indeterminate', 'none'
+        """
+        pass
+
+    # --- System Integration (OS Hooks) ---
+
+    def register_protocol(self, scheme: str) -> bool:
+        return False
+
+    def set_launch_on_boot(
+        self, app_name: str, exe_path: str, enable: bool = True
+    ) -> bool:
+        return False
+
+    def set_app_id(self, app_id: str) -> None:
+        pass
+
+    def get_system_info(self) -> Dict:
+        return {}
+
+    # --- Clipboard ---
+
+    def set_clipboard_text(self, text: str) -> bool:
+        return False
+
+    def get_clipboard_text(self) -> Optional[str]:
+        return None
+
+    # --- UI Polish ---
+
+    def set_slim_titlebar(self, w: WindowHandle, enabled: bool) -> None:
+        pass