pyloid 0.22.0.dev1__tar.gz → 0.22.0.dev2__tar.gz

{pyloid-0.22.0.dev1 → pyloid-0.22.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyloid
-Version: 0.22.0.dev1
+Version: 0.22.0.dev2
 Summary: 
 Author: aesthetics-of-record
 Author-email: 111675679+aesthetics-of-record@users.noreply.github.com

{pyloid-0.22.0.dev1 → pyloid-0.22.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyloid"
-version = "0.22.0-dev1"
+version = "0.22.0-dev2"
 description = ""
 authors = ["aesthetics-of-record <111675679+aesthetics-of-record@users.noreply.github.com>"]
 readme = "README.md"

{pyloid-0.22.0.dev1 → pyloid-0.22.0.dev2}/src/pyloid/__init__.py

@@ -3,5 +3,6 @@ from .api import PyloidAPI, Bridge
 from .utils import get_production_path, is_production
 from .tray import TrayEvent
 from .timer import PyloidTimer
+from .serve import pyloid_serve
 
-__all__ = ['Pyloid', 'PyloidAPI', 'Bridge', 'get_production_path', 'is_production', 'TrayEvent', 'PyloidTimer']
+__all__ = ['Pyloid', 'PyloidAPI', 'Bridge', 'get_production_path', 'is_production', 'TrayEvent', 'PyloidTimer', 'serve']

{pyloid-0.22.0.dev1 → pyloid-0.22.0.dev2}/src/pyloid/browser_window.py

@@ -533,7 +533,7 @@ class _BrowserWindow:
                     
                     document.addEventListener('mousedown', function (e) {
                         if (e.target.hasAttribute('data-pyloid-drag-region')) {
-                            window.pyloid.WindowAPI.startSystemDrag();
+                            window.pyloid.BaseAPI.startSystemDrag();
                         }
                     });
                     
@@ -2013,7 +2013,7 @@ class BrowserWindow(QObject):
     
     def __init__(self, app, title: str, width: int, height: int, x: int, y: int, frame: bool, context_menu: bool, dev_tools: bool, js_apis: List[PyloidAPI]):
         super().__init__()
-        self.window = _BrowserWindow(app, title, width, height, x, y, frame, context_menu, dev_tools, js_apis)
+        self._window = _BrowserWindow(app, title, width, height, x, y, frame, context_menu, dev_tools, js_apis)
         self.command_signal.connect(self._handle_command)
     
     @Slot(str, str, object)
@@ -2029,97 +2029,97 @@ class BrowserWindow(QObject):
         result = None
 
         if command_type == "load_file":
-            result = self.window.load_file(params["file_path"])
+            result = self._window.load_file(params["file_path"])
         elif command_type == "load_url":
-            result = self.window.load_url(params["url"])
+            result = self._window.load_url(params["url"])
         elif command_type == "load_html":
             html_content = params.get("html_content", "")
             base_url = params.get("base_url", "")
-            result = self.window.load_html(html_content, base_url)
+            result = self._window.load_html(html_content, base_url)
         elif command_type == "set_title":
-            result = self.window.set_title(params["title"])
+            result = self._window.set_title(params["title"])
         elif command_type == "set_size":
-            result = self.window.set_size(params["width"], params["height"])
+            result = self._window.set_size(params["width"], params["height"])
         elif command_type == "set_position":
-            result = self.window.set_position(params["x"], params["y"])
+            result = self._window.set_position(params["x"], params["y"])
         elif command_type == "set_position_by_anchor":
-            result = self.window.set_position_by_anchor(params["anchor"])
+            result = self._window.set_position_by_anchor(params["anchor"])
         elif command_type == "set_frame":
-            result = self.window.set_frame(params["frame"])
+            result = self._window.set_frame(params["frame"])
         elif command_type == "set_context_menu":
-            result = self.window.set_context_menu(params["context_menu"])
+            result = self._window.set_context_menu(params["context_menu"])
         elif command_type == "set_dev_tools":
-            result = self.window.set_dev_tools(params["enable"])
+            result = self._window.set_dev_tools(params["enable"])
         elif command_type == "open_dev_tools":
-            result = self.window.open_dev_tools()
+            result = self._window.open_dev_tools()
         elif command_type == "hide":
-            result = self.window.hide()
+            result = self._window.hide()
         elif command_type == "show":
-            result = self.window.show()
+            result = self._window.show()
         elif command_type == "focus":
-            result = self.window.focus()
+            result = self._window.focus()
         elif command_type == "show_and_focus":
-            result = self.window.show_and_focus()
+            result = self._window.show_and_focus()
         elif command_type == "close":
-            result = self.window.close()
+            result = self._window.close()
         elif command_type == "fullscreen":
-            result = self.window.fullscreen()
+            result = self._window.fullscreen()
         elif command_type == "toggle_fullscreen":
-            result = self.window.toggle_fullscreen()
+            result = self._window.toggle_fullscreen()
         elif command_type == "minimize":
-            result = self.window.minimize()
+            result = self._window.minimize()
         elif command_type == "maximize":
-            result = self.window.maximize()
+            result = self._window.maximize()
         elif command_type == "unmaximize":
-            result = self.window.unmaximize()
+            result = self._window.unmaximize()
         elif command_type == "toggle_maximize":
-            result = self.window.toggle_maximize()
+            result = self._window.toggle_maximize()
         elif command_type == "is_fullscreen":
-            result = self.window.is_fullscreen()
+            result = self._window.is_fullscreen()
         elif command_type == "is_maximized":
-            result = self.window.is_maximized()
+            result = self._window.is_maximized()
         elif command_type == "capture":
-            result = self.window.capture(params["save_path"])
+            result = self._window.capture(params["save_path"])
         elif command_type == "add_shortcut":
-            result = self.window.add_shortcut(params["key_sequence"], params["callback"])
+            result = self._window.add_shortcut(params["key_sequence"], params["callback"])
         elif command_type == "remove_shortcut":
-            result = self.window.remove_shortcut(params["key_sequence"])
+            result = self._window.remove_shortcut(params["key_sequence"])
         elif command_type == "get_all_shortcuts":
-            result = self.window.get_all_shortcuts()
+            result = self._window.get_all_shortcuts()
         elif command_type == "emit":
             event_name = params["event_name"]
             data = params.get("data")
-            result = self.window.invoke(event_name, data)
+            result = self._window.invoke(event_name, data)
         elif command_type == "get_window_properties":
-            result = self.window.get_window_properties()
+            result = self._window.get_window_properties()
         elif command_type == "get_id":
-            result = self.window.get_id()
+            result = self._window.get_id()
         elif command_type == "get_size":
-            result = self.window.get_size()
+            result = self._window.get_size()
         elif command_type == "get_position":
-            result = self.window.get_position()
+            result = self._window.get_position()
         elif command_type == "get_title":
-            result = self.window.get_title()
+            result = self._window.get_title()
         elif command_type == "get_url":
-            result = self.window.get_url()
+            result = self._window.get_url()
         elif command_type == "get_visible":
-            result = self.window.get_visible()
+            result = self._window.get_visible()
         elif command_type == "get_frame":
-            result = self.window.get_frame()
+            result = self._window.get_frame()
         elif command_type == "set_resizable":
-            result = self.window.set_resizable(params["resizable"])
+            result = self._window.set_resizable(params["resizable"])
         elif command_type == "set_minimum_size":
-            result = self.window.set_minimum_size(params["min_width"], params["min_height"])
+            result = self._window.set_minimum_size(params["min_width"], params["min_height"])
         elif command_type == "set_maximum_size":
-            result = self.window.set_maximum_size(params["max_width"], params["max_height"])
+            result = self._window.set_maximum_size(params["max_width"], params["max_height"])
         elif command_type == "get_minimum_size":
-            result = self.window.get_minimum_size()
+            result = self._window.get_minimum_size()
         elif command_type == "get_maximum_size":
-            result = self.window.get_maximum_size()
+            result = self._window.get_maximum_size()
         elif command_type == "get_resizable":
-            result = self.window.get_resizable()
+            result = self._window.get_resizable()
         elif command_type == "set_static_image_splash_screen":
-            result = self.window.set_static_image_splash_screen(
+            result = self._window.set_static_image_splash_screen(
                 params["image_path"],
                 params.get("close_on_load", True),
                 params.get("stay_on_top", True),
@@ -2127,7 +2127,7 @@ class BrowserWindow(QObject):
                 params.get("position", "center")
             )
         elif command_type == "set_gif_splash_screen":
-            result = self.window.set_gif_splash_screen(
+            result = self._window.set_gif_splash_screen(
                 params["gif_path"],
                 params.get("close_on_load", True),
                 params.get("stay_on_top", True),
@@ -2135,7 +2135,7 @@ class BrowserWindow(QObject):
                 params.get("position", "center")
             )
         elif command_type == "close_splash_screen":
-            result = self.window.close_splash_screen()
+            result = self._window.close_splash_screen()
         else:
             return None
 

pyloid-0.22.0.dev2/src/pyloid/js_api/base.py

@@ -0,0 +1,29 @@
+from ..api import PyloidAPI, Bridge
+
+class BaseAPI(PyloidAPI):
+    def __init__(self, window_id: str, data: dict):
+        super().__init__()
+        self.window_id: str = window_id
+        self.data: dict = data
+
+    @Bridge(result=dict)
+    def getData(self):
+        """Returns the shared data of the application."""
+        return self.data
+    
+    @Bridge(result=str)
+    def getWindowId(self):
+        """Returns the current window ID."""
+        return self.window_id
+    
+    @Bridge()
+    def startSystemDrag(self):
+        """Starts the system drag."""
+        window = self.app.get_window_by_id(self.window_id)
+        if window:
+            window._window.web_view.start_system_drag()
+    
+    @Bridge()
+    def quit(self):
+        """Quits the application."""
+        self.app.quit() 

{pyloid-0.22.0.dev1 → pyloid-0.22.0.dev2}/src/pyloid/pyloid.py

@@ -299,7 +299,7 @@ class _Pyloid(QApplication):
             dev_tools,
             js_apis,
         )
-        self.windows_dict[window.window.id] = window
+        self.windows_dict[window._window.id] = window
         return window
 
     def run(self):
@@ -1486,30 +1486,6 @@ class Pyloid(QObject):
         elif command_type == "get_window_by_id":
             result = self.app.get_window_by_id(params["window_id"])
 
-        elif command_type == "hide_window_by_id":
-            result = self.app.hide_window_by_id(params["window_id"])
-
-        elif command_type == "show_window_by_id":
-            result = self.app.show_window_by_id(params["window_id"])
-
-        elif command_type == "close_window_by_id":
-            result = self.app.close_window_by_id(params["window_id"])
-
-        elif command_type == "toggle_fullscreen_by_id":
-            result = self.app.toggle_fullscreen_by_id(params["window_id"])
-
-        elif command_type == "minimize_window_by_id":
-            result = self.app.minimize_window_by_id(params["window_id"])
-
-        elif command_type == "maximize_window_by_id":
-            result = self.app.maximize_window_by_id(params["window_id"])
-
-        elif command_type == "unmaximize_window_by_id":
-            result = self.app.unmaximize_window_by_id(params["window_id"])
-
-        elif command_type == "capture_window_by_id":
-            result = self.app.capture_window_by_id(params["window_id"], params["save_path"])
-
         elif command_type == "set_tray_icon":
             result = self.app.set_tray_icon(params["tray_icon_path"])
 
@@ -1802,141 +1778,6 @@ class Pyloid(QObject):
         """
         return self.execute_command("get_window_by_id", {"window_id": window_id})
     
-    def hide_window_by_id(self, window_id: str) -> None:
-        """
-        Hides the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to hide
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.hide_window_by_id("some-window-id")
-        """
-        return self.execute_command("hide_window_by_id", {"window_id": window_id})
-    
-    def show_window_by_id(self, window_id: str) -> None:
-        """
-        Shows and focuses the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to show
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.show_window_by_id("some-window-id")
-        """
-        return self.execute_command("show_window_by_id", {"window_id": window_id})
-    
-    def close_window_by_id(self, window_id: str) -> None:
-        """
-        Closes the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to close
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.close_window_by_id("some-window-id")
-        """
-        return self.execute_command("close_window_by_id", {"window_id": window_id})
-    
-    def toggle_fullscreen_by_id(self, window_id: str) -> None:
-        """
-        Toggles fullscreen mode for the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to toggle fullscreen mode
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.toggle_fullscreen_by_id("some-window-id")
-        """
-        return self.execute_command("toggle_fullscreen_by_id", {"window_id": window_id})
-    
-    def minimize_window_by_id(self, window_id: str) -> None:
-        """
-        Minimizes the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to minimize
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.minimize_window_by_id("some-window-id")
-        """
-        return self.execute_command("minimize_window_by_id", {"window_id": window_id})
-    
-    def maximize_window_by_id(self, window_id: str) -> None:
-        """
-        Maximizes the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to maximize
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.maximize_window_by_id("some-window-id")
-        """
-        return self.execute_command("maximize_window_by_id", {"window_id": window_id})
-    
-    def unmaximize_window_by_id(self, window_id: str) -> None:
-        """
-        Unmaximizes the window with the given ID.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to unmaximize
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> app.unmaximize_window_by_id("some-window-id")
-        """
-        return self.execute_command("unmaximize_window_by_id", {"window_id": window_id})
-    
-    def capture_window_by_id(self, window_id: str, save_path: str) -> Optional[str]:
-        """
-        Captures the specified window.
-
-        Parameters
-        ----------
-        window_id : str
-            The ID of the window to capture
-        save_path : str
-            The path to save the captured image
-
-        Returns
-        -------
-        Optional[str]
-            The path of the saved image. Returns None if the window is not found or an error occurs.
-
-        Examples
-        --------
-        >>> app = Pyloid(app_name="Pyloid-App")
-        >>> image_path = app.capture_window_by_id("some-window-id", "save/image.png")
-        """
-        return self.execute_command("capture_window_by_id", {"window_id": window_id, "save_path": save_path})
-    
     def set_tray_icon(self, tray_icon_path: str) -> bool:
         """
         Dynamically sets the tray icon.

pyloid-0.22.0.dev2/src/pyloid/serve.py

@@ -0,0 +1,56 @@
+import threading
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from typing import Optional
+from .utils import get_free_port
+
+class CustomStaticHandler(SimpleHTTPRequestHandler):
+    def __init__(self, *args, directory=None, **kwargs):
+        super().__init__(*args, directory=directory, **kwargs)
+    
+    def log_message(self, format, *args):
+        pass
+
+def pyloid_serve(
+    directory: str,
+    port: Optional[int] = None,
+) -> str:
+    """
+    Static file server starts.
+    
+    Args
+    ----
+    directory (str): Path to the static file directory to serve
+    port (int, optional): Server port (default: None - will use a random free port)
+    
+    Returns
+    -------
+    str
+        URL of the started server
+        
+    Examples
+    --------
+    ```python
+    from pyloid import Pyloid
+    from pyloid.serve import pyloid_serve
+    
+    app = Pyloid("Pyloid-App")
+    url = pyloid_serve("dist")
+    window = app.create_window("Pyloid-App")
+    window.load_url(url)
+    window.show_and_focus()
+    ```
+    """
+    
+    if port is None:
+        port = get_free_port()
+    
+    handler = lambda *args: CustomStaticHandler(*args, directory=directory)
+    server = HTTPServer(("127.0.0.1", port), handler)
+    
+    thread = threading.Thread(
+        target=server.serve_forever,
+        daemon=True
+    )
+    thread.start()
+    
+    return f"http://127.0.0.1:{port}"

{pyloid-0.22.0.dev1 → pyloid-0.22.0.dev2}/src/pyloid/utils.py

@@ -122,6 +122,37 @@ def get_absolute_path(path: str) -> str:
     return os.path.normpath(os.path.abspath(path))
 
 def get_free_port() -> int:
+    """
+    Finds and returns an available random network port number from the operating system.
+    
+    This function creates a socket and binds it to port '0', allowing the operating system
+    to allocate a random available port. It retrieves the port number and safely closes
+    the socket afterward.
+    
+    Returns
+    -------
+    int
+        An available network port number (typically in the range 1024-65535)
+    
+    Notes
+    -----
+    - Since this function closes the socket immediately after finding a port, there is a
+      possibility that the port could be reassigned to another process.
+    - It is recommended to use the port number quickly after receiving it.
+    - This function interacts with the operating system's network stack, so its behavior
+      may vary depending on firewall or network settings.
+    
+    Examples
+    --------
+    >>> from pyloid.utils import get_free_port
+    >>> port = get_free_port()
+    >>> print(f"Found available port: {port}")
+    Found available port: 49152
+    
+    >>> # Web server example
+    >>> import http.server
+    >>> server = http.server.HTTPServer(('localhost', port), http.server.SimpleHTTPRequestHandler)
+    """
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         s.bind(('', 0))
         return s.getsockname()[1]

pyloid-0.22.0.dev1/src/pyloid/js_api/base.py

@@ -1,13 +0,0 @@
-from ..api import PyloidAPI, Bridge
-
-class BaseAPI(PyloidAPI):
-    def __init__(self, window_id: str, data: dict):
-        super().__init__()
-        self.window_id: str = window_id
-        self.data: dict = data
-
-    @Bridge(result=str)
-    def get_data(self):
-        """Returns the shared data of the application."""
-        return self.data
-