pyloid 0.24.4.dev0__py3-none-any.whl → 0.24.6__py3-none-any.whl

pyloid/browser_window.py

@@ -40,7 +40,7 @@ from PySide6.QtWidgets import QSplashScreen, QLabel
 from typing import TYPE_CHECKING, Any
 from PySide6.QtWebEngineCore import (
     QWebEngineSettings,
-    # QWebEngineDesktopMediaRequest, # 6.8.3 부터
+    QWebEngineDesktopMediaRequest,
 )
 import threading
 
@@ -55,7 +55,7 @@ class CustomWebPage(QWebEnginePage):
     def __init__(self, profile=None):
         super().__init__(profile)
         self.featurePermissionRequested.connect(self._handlePermissionRequest)
-        # self.desktopMediaRequested.connect(self._handleDesktopMediaRequest)
+        self.desktopMediaRequested.connect(self._handleDesktopMediaRequest)
         self._permission_handlers = {}
         self._desktop_media_handler = None
         self._url_handlers = {}  # URL 핸들러 저장을 위한 딕셔너리 추가
@@ -78,27 +78,27 @@ class CustomWebPage(QWebEnginePage):
         """Register a handler for a specific permission"""
         self._permission_handlers[feature] = handler
 
-    # def _handleDesktopMediaRequest(self, request: QWebEngineDesktopMediaRequest):
-    #     return
-    #     print("Desktop media request received:", request)
+    def _handleDesktopMediaRequest(self, request: QWebEngineDesktopMediaRequest):
+        return
+        print("Desktop media request received:", request)
 
-    #     # 사용 가능한 화면 목록 확인
-    #     screens_model = request.screensModel()
-    #     print("\n=== Available Screens ===")
-    #     for i in range(screens_model.rowCount()):
-    #         screen_index = screens_model.index(i)
-    #         screen_name = screens_model.data(screen_index)
-    #         print(f"Screen {i}: {screen_name}")
+        # 사용 가능한 화면 목록 확인
+        screens_model = request.screensModel()
+        print("\n=== Available Screens ===")
+        for i in range(screens_model.rowCount()):
+            screen_index = screens_model.index(i)
+            screen_name = screens_model.data(screen_index)
+            print(f"Screen {i}: {screen_name}")
 
-    #     # 사용 가능한 창 목록 확인
-    #     windows_model = request.windowsModel()
-    #     print("\n=== Available Windows ===")
-    #     for i in range(windows_model.rowCount()):
-    #         window_index = windows_model.index(i)
-    #         window_name = windows_model.data(window_index)
-    #         print(f"Window {i}: {window_name}")
+        # 사용 가능한 창 목록 확인
+        windows_model = request.windowsModel()
+        print("\n=== Available Windows ===")
+        for i in range(windows_model.rowCount()):
+            window_index = windows_model.index(i)
+            window_name = windows_model.data(window_index)
+            print(f"Window {i}: {window_name}")
 
-    #     request.selectWindow(windows_model.index(3))
+        request.selectWindow(windows_model.index(3))
 
     # # interceptor ( navigation request )
     # def acceptNavigationRequest(self, url, navigation_type, is_main_frame):
@@ -317,6 +317,7 @@ class _BrowserWindow:
         dev_tools: bool = False,
         # js_apis: List[PyloidAPI] = [],
         rpc: Optional[PyloidRPC] = None,
+        transparent: bool = False,
     ):
         ###########################################################################################
         self.id = str(uuid.uuid4())  # Generate unique ID
@@ -344,6 +345,7 @@ class _BrowserWindow:
         self.x = x
         self.y = y
         self.frame = frame
+        self.transparent = transparent
         self.context_menu = context_menu
         self.dev_tools = dev_tools
 
@@ -413,6 +415,20 @@ class _BrowserWindow:
 
         self._window.show()
 
+    def _apply_transparency(self):
+        """Applies transparency settings based on self.transparent and self.frame."""
+        if self.transparent:
+            # It's generally better if FramelessWindowHint is set for full transparency,
+            # but WA_TranslucentBackground can still have effects otherwise.
+            self._window.setAttribute(Qt.WA_TranslucentBackground, True)
+            self.web_view.setAttribute(Qt.WA_TranslucentBackground, True)
+            self.web_view.page().setBackgroundColor(Qt.transparent)
+        else:
+            self._window.setAttribute(Qt.WA_TranslucentBackground, False)
+            self.web_view.setAttribute(Qt.WA_TranslucentBackground, False)
+            # Reset background color for web_view page, QColor() or a specific color like Qt.white
+            self.web_view.page().setBackgroundColor(Qt.white)
+
     def _load(self):
         self.set_title(self.title)
 
@@ -491,9 +507,11 @@ class _BrowserWindow:
         # Remove title bar and borders (if needed)
         if not self.frame:
             self._window.setWindowFlags(Qt.FramelessWindowHint)
-            self._window.setAttribute(Qt.WA_TranslucentBackground)
-            self.web_view.setAttribute(Qt.WA_TranslucentBackground)
-            self.web_view.page().setBackgroundColor(Qt.transparent)
+        else:
+            # Ensure standard window flags if frame is True, otherwise flags might be missing
+            self._window.setWindowFlags(Qt.Window)
+
+        self._apply_transparency()
 
         # Disable default context menu
         if not self.context_menu:
@@ -817,12 +835,43 @@ class _BrowserWindow:
             self._window.setWindowFlags(Qt.Window)
         else:
             self._window.setWindowFlags(Qt.FramelessWindowHint)
-            self._window.setAttribute(Qt.WA_TranslucentBackground)
-            self.web_view.setAttribute(Qt.WA_TranslucentBackground)
-            self.web_view.page().setBackgroundColor(Qt.transparent)
+
+        self._apply_transparency()
+
         if was_visible:
             self._window.show()
 
+    def set_transparent(self, transparent: bool):
+        """
+        Sets the transparency of the window.
+
+        Parameters
+        ----------
+        transparent : bool
+            If True, the window background will be transparent.
+            If False, it will be opaque.
+
+        Examples
+        --------
+        >>> window.set_transparent(True)
+        """
+        self.transparent = transparent
+        self._apply_transparency()
+
+        if self._window.isVisible():
+            self._window.show()
+
+    def get_transparent(self) -> bool:
+        """
+        Returns the transparency state of the window.
+
+        Returns
+        -------
+        bool
+            True if the window is set to be transparent, False otherwise.
+        """
+        return self.transparent
+
     def set_context_menu(self, context_menu: bool):
         """
         Sets the context menu of the window.
@@ -1296,6 +1345,7 @@ class _BrowserWindow:
             "x": self.x,
             "y": self.y,
             "frame": self.frame,
+            "transparent": self.transparent,  # Add transparent to properties
             "context_menu": self.context_menu,
             "dev_tools": self.dev_tools,
         }
@@ -2069,14 +2119,26 @@ class BrowserWindow(QObject):
         height: int,
         x: int,
         y: int,
-        frame: bool,
-        context_menu: bool,
-        dev_tools: bool,
+        frame: bool = True,
+        context_menu: bool = False,
+        dev_tools: bool = False,
         rpc: Optional[PyloidRPC] = None,
+        transparent: bool = False,
     ):
         super().__init__()
         self._window = _BrowserWindow(
-            app, self, title, width, height, x, y, frame, context_menu, dev_tools, rpc
+            app,
+            self,
+            title,
+            width,
+            height,
+            x,
+            y,
+            frame,
+            context_menu,
+            dev_tools,
+            rpc,
+            transparent,
         )
         self.command_signal.connect(self._handle_command)
 
@@ -2112,6 +2174,10 @@ class BrowserWindow(QObject):
             result = self._window.set_position_by_anchor(params["anchor"])
         elif command_type == "set_frame":
             result = self._window.set_frame(params["frame"])
+        elif command_type == "set_transparent":
+            result = self._window.set_transparent(params["transparent"])
+        elif command_type == "get_transparent":
+            result = self._window.get_transparent()
         elif command_type == "set_context_menu":
             result = self._window.set_context_menu(params["context_menu"])
         elif command_type == "set_dev_tools":
@@ -2395,6 +2461,34 @@ class BrowserWindow(QObject):
         """
         return self.execute_command("set_frame", {"frame": frame})
 
+    # TODO: Can't use this function in runtime
+    # def set_transparent(self, transparent: bool) -> None:
+    #     """
+    #     Sets the transparency of the window.
+
+    #     Parameters
+    #     ----------
+    #     transparent : bool
+    #         If True, the window background will be transparent.
+    #         If False, it will be opaque.
+
+    #     Examples
+    #     --------
+    #     >>> window.set_transparent(True)
+    #     """
+    #     return self.execute_command("set_transparent", {"transparent": transparent})
+
+    def get_transparent(self) -> bool:
+        """
+        Returns the transparency state of the window.
+
+        Returns
+        -------
+        bool
+            True if the window is set to be transparent, False otherwise.
+        """
+        return self.execute_command("get_transparent", {})
+
     def set_context_menu(self, context_menu: bool) -> None:
         """
         Sets the context menu of the window.

pyloid/pyloid.py

@@ -243,6 +243,7 @@ class _Pyloid(QApplication):
         context_menu: bool = False,
         dev_tools: bool = False,
         rpc: Optional[PyloidRPC] = None,
+        transparent: bool = False,
     ) -> BrowserWindow:
         """
         Creates a new browser window.
@@ -267,6 +268,8 @@ class _Pyloid(QApplication):
             Whether to use developer tools (default is False)
         rpc : PyloidRPC, optional
             The RPC server instance to be used in the window
+        transparent : bool, optional
+            Whether the window is transparent (default is False)
 
         Returns
         -------
@@ -290,6 +293,7 @@ class _Pyloid(QApplication):
             context_menu,
             dev_tools,
             rpc,
+            transparent,
         )
         self.windows_dict[window._window.id] = window
         # latest_window_id = list(self.windows_dict.keys())[-1]
@@ -1654,6 +1658,7 @@ class Pyloid(QObject):
                 context_menu=params.get("context_menu", False),
                 dev_tools=params.get("dev_tools", False),
                 rpc=params.get("rpc", None),
+                transparent=params.get("transparent", False),
             )
             result = window
 
@@ -1829,6 +1834,7 @@ class Pyloid(QObject):
         context_menu: bool = False,
         dev_tools: bool = False,
         rpc: Optional[PyloidRPC] = None,
+        transparent: bool = False,
     ) -> BrowserWindow:
         """
         Creates a new browser window.
@@ -1853,6 +1859,8 @@ class Pyloid(QObject):
             Whether to use developer tools (default is False)
         rpc : PyloidRPC, optional
             The RPC server instance to be used in the window
+        transparent : bool, optional
+            Whether the window is transparent (default is False)
 
         Returns
         -------
@@ -1874,6 +1882,7 @@ class Pyloid(QObject):
             "context_menu": context_menu,
             "dev_tools": dev_tools,
             "rpc": rpc,
+            "transparent": transparent,
         }
         return self.execute_command("create_window", params)
 

pyloid/rpc.py

@@ -10,6 +10,7 @@ import threading
 import time
 import aiohttp_cors
 from typing import TYPE_CHECKING
+
 if TYPE_CHECKING:
     from .pyloid import Pyloid
     from .browser_window import BrowserWindow
@@ -18,10 +19,11 @@ if TYPE_CHECKING:
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger("pyloid.rpc")
 
+
 class RPCContext:
     """
     Class that provides context information when calling RPC methods.
-    
+
     Attributes
     ----------
     pyloid : Pyloid
@@ -29,10 +31,12 @@ class RPCContext:
     window : BrowserWindow
         Current browser window instance.
     """
+
     def __init__(self, pyloid: "Pyloid", window: "BrowserWindow"):
         self.pyloid: "Pyloid" = pyloid
         self.window: "BrowserWindow" = window
 
+
 class RPCError(Exception):
     """
     Custom exception for RPC-related errors.
@@ -50,6 +54,7 @@ class RPCError(Exception):
     data : Any, optional
         Additional information about the error, by default None.
     """
+
     def __init__(self, message: str, code: int = -32000, data: Any = None):
         """
         Initialize the RPCError.
@@ -82,6 +87,7 @@ class RPCError(Exception):
             error_obj["data"] = self.data
         return error_obj
 
+
 class PyloidRPC:
     """
     A simple JSON-RPC server wrapper based on aiohttp.
@@ -104,17 +110,23 @@ class PyloidRPC:
     _app : web.Application
         The underlying aiohttp web application instance.
     """
-    def __init__(self):
+
+    def __init__(self, client_max_size: int = 1024 * 1024 * 10):
         """
         Initialize the PyloidRPC server instance.
-        
+
+        Parameters
+        ----------
+        client_max_size : int, optional
+            The maximum size of client requests (bytes). Default is 10MB.
+
         Examples
         --------
         ```python
         from pyloid.rpc import PyloidRPC
-        
+
         rpc = PyloidRPC()
-        
+
         @rpc.method()
         async def add(a: int, b: int) -> int:
             return a + b
@@ -123,29 +135,32 @@ class PyloidRPC:
         self._host = "127.0.0.1"
         self._port = get_free_port()
         self._rpc_path = "/rpc"
-        
+
         self.url = f"http://{self._host}:{self._port}{self._rpc_path}"
-        
+
         self._functions: Dict[str, Callable[..., Coroutine[Any, Any, Any]]] = {}
-        self._app = web.Application()
-        
+        self._app = web.Application(client_max_size=client_max_size)
+
         self.pyloid: Optional["Pyloid"] = None
         # self.window: Optional["BrowserWindow"] = None
-        
+
         # CORS 설정 추가
-        cors = aiohttp_cors.setup(self._app, defaults={
-            "*": aiohttp_cors.ResourceOptions(
-                allow_credentials=True,
-                expose_headers="*",
-                allow_headers="*",
-                allow_methods=["POST"]
-            )
-        })
-        
+        cors = aiohttp_cors.setup(
+            self._app,
+            defaults={
+                "*": aiohttp_cors.ResourceOptions(
+                    allow_credentials=True,
+                    expose_headers="*",
+                    allow_headers="*",
+                    allow_methods=["POST"],
+                )
+            },
+        )
+
         # CORS 적용된 라우트 추가
         resource = cors.add(self._app.router.add_resource(self._rpc_path))
         cors.add(resource.add_route("POST", self._handle_rpc))
-        
+
         log.info(f"RPC server initialized.")
         self._runner: Optional[web.AppRunner] = None
         self._site: Optional[web.TCPSite] = None
@@ -153,7 +168,7 @@ class PyloidRPC:
     def method(self, name: Optional[str] = None) -> Callable:
         """
         Use a decorator to register an async function as an RPC method.
-        
+
         If there is a 'ctx' parameter, an RPCContext object is automatically injected.
         This object allows access to the pyloid application and current window.
 
@@ -173,14 +188,14 @@ class PyloidRPC:
             If the decorated function is not an async function (`coroutinefunction`).
         ValueError
             If an RPC function with the specified name is already registered.
-            
+
         Examples
         --------
         ```python
         from pyloid.rpc import PyloidRPC, RPCContext
-        
+
         rpc = PyloidRPC()
-        
+
         @rpc.method()
         async def add(ctx: RPCContext, a: int, b: int) -> int:
             # Access the application and window through ctx.pyloid and ctx.window
@@ -189,31 +204,36 @@ class PyloidRPC:
             return a + b
         ```
         """
+
         def decorator(func: Callable[..., Coroutine[Any, Any, Any]]):
             rpc_name = name or func.__name__
             if not asyncio.iscoroutinefunction(func):
                 raise TypeError(f"RPC function '{rpc_name}' must be an async function.")
             if rpc_name in self._functions:
-                raise ValueError(f"RPC function name '{rpc_name}' is already registered.")
+                raise ValueError(
+                    f"RPC function name '{rpc_name}' is already registered."
+                )
 
             # Analyze function signature
             sig = inspect.signature(func)
-            has_ctx_param = 'ctx' in sig.parameters
-            
+            has_ctx_param = "ctx" in sig.parameters
+
             # Store the original function
             self._functions[rpc_name] = func
             log.info(f"RPC function registered: {rpc_name}")
 
             @wraps(func)
             async def wrapper(*args, _pyloid_window_id=None, **kwargs):
-                if has_ctx_param and 'ctx' not in kwargs:
+                if has_ctx_param and "ctx" not in kwargs:
                     ctx = RPCContext(
                         pyloid=self.pyloid,
-                        window=self.pyloid.get_window_by_id(_pyloid_window_id)
+                        window=self.pyloid.get_window_by_id(_pyloid_window_id),
                     )
-                    kwargs['ctx'] = ctx
+                    kwargs["ctx"] = ctx
                 return await func(*args, **kwargs)
+
             return wrapper
+
         return decorator
 
     def _validate_jsonrpc_request(self, data: Any) -> Optional[Dict[str, Any]]:
@@ -239,19 +259,31 @@ class PyloidRPC:
         request_id = data.get("id") if isinstance(data, dict) else None
 
         if not isinstance(data, dict):
-            return {"code": -32600, "message": "Invalid Request: Request must be a JSON object."}
+            return {
+                "code": -32600,
+                "message": "Invalid Request: Request must be a JSON object.",
+            }
         if data.get("jsonrpc") != "2.0":
-            return {"code": -32600, "message": "Invalid Request: 'jsonrpc' version must be '2.0'."}
+            return {
+                "code": -32600,
+                "message": "Invalid Request: 'jsonrpc' version must be '2.0'.",
+            }
         if "method" not in data or not isinstance(data["method"], str):
-            return {"code": -32600, "message": "Invalid Request: 'method' must be a string."}
+            return {
+                "code": -32600,
+                "message": "Invalid Request: 'method' must be a string.",
+            }
         if "params" in data and not isinstance(data["params"], (list, dict)):
             # JSON-RPC 2.0: "params" must be array or object if present
-            return {"code": -32602, "message": "Invalid params: 'params' must be an array or object."}
+            return {
+                "code": -32602,
+                "message": "Invalid params: 'params' must be an array or object.",
+            }
         # JSON-RPC 2.0: "id" is optional, but if present, must be string, number, or null.
         # This validation is simplified here. A more robust check could be added.
         # if "id" in data and not isinstance(data.get("id"), (str, int, float, type(None))):
         #     return {"code": -32600, "message": "Invalid Request: 'id', if present, must be a string, number, or null."}
-        return None # Request structure is valid
+        return None  # Request structure is valid
 
     async def _handle_rpc(self, request: web.Request) -> web.Response:
         """
@@ -272,14 +304,23 @@ class PyloidRPC:
             An aiohttp JSON response object containing the JSON-RPC response or error.
         """
         request_id: Optional[Union[str, int, None]] = None
-        data: Any = None # Define data outside try block for broader scope if needed
+        data: Any = None  # Define data outside try block for broader scope if needed
 
         try:
             # 1. Check Content-Type
-            if request.content_type != 'application/json':
-                 # Cannot determine ID if content type is wrong, respond with null ID
-                 error_resp = {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error: Content-Type must be application/json."}, "id": None}
-                 return web.json_response(error_resp, status=415) # Unsupported Media Type
+            if request.content_type != "application/json":
+                # Cannot determine ID if content type is wrong, respond with null ID
+                error_resp = {
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Content-Type must be application/json.",
+                    },
+                    "id": None,
+                }
+                return web.json_response(
+                    error_resp, status=415
+                )  # Unsupported Media Type
 
             # 2. Parse JSON Body
             try:
@@ -287,18 +328,29 @@ class PyloidRPC:
                 data = json.loads(raw_data)
                 # Extract ID early for inclusion in potential error responses
                 if isinstance(data, dict):
-                    request_id = data.get("id") # Can be str, int, null, or absent
+                    request_id = data.get("id")  # Can be str, int, null, or absent
             except json.JSONDecodeError:
                 # Invalid JSON, ID might be unknown, respond with null ID
-                error_resp = {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error: Invalid JSON format."}, "id": None}
-                return web.json_response(error_resp, status=400) # Bad Request
+                error_resp = {
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON format.",
+                    },
+                    "id": None,
+                }
+                return web.json_response(error_resp, status=400)  # Bad Request
 
             # 3. Validate JSON-RPC Structure
             validation_error = self._validate_jsonrpc_request(data)
             if validation_error:
-                 # Use extracted ID if available, otherwise it remains None
-                 error_resp = {"jsonrpc": "2.0", "error": validation_error, "id": request_id}
-                 return web.json_response(error_resp, status=400) # Bad Request
+                # Use extracted ID if available, otherwise it remains None
+                error_resp = {
+                    "jsonrpc": "2.0",
+                    "error": validation_error,
+                    "id": request_id,
+                }
+                return web.json_response(error_resp, status=400)  # Bad Request
 
             # Assuming validation passed, data is a dict with 'method'
             method_name: str = data["method"]
@@ -308,48 +360,63 @@ class PyloidRPC:
             # 4. Find and Call Method
             func = self._functions.get(method_name)
             if func is None:
-                error_resp = {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found."}, "id": request_id}
-                return web.json_response(error_resp, status=404) # Not Found
+                error_resp = {
+                    "jsonrpc": "2.0",
+                    "error": {"code": -32601, "message": "Method not found."},
+                    "id": request_id,
+                }
+                return web.json_response(error_resp, status=404)  # Not Found
 
             try:
                 log.debug(f"Executing RPC method: {method_name}(params={params})")
-                
+
                 # 함수의 서명 분석하여 ctx 매개변수 유무 확인
                 sig = inspect.signature(func)
-                has_ctx_param = 'ctx' in sig.parameters
-                
+                has_ctx_param = "ctx" in sig.parameters
+
                 # ctx 매개변수가 있으면 컨텍스트 객체 생성
-                if has_ctx_param and isinstance(params, dict) and 'ctx' not in params:
+                if has_ctx_param and isinstance(params, dict) and "ctx" not in params:
                     ctx = RPCContext(
                         pyloid=self.pyloid,
-                        window=self.pyloid.get_window_by_id(request_id)
+                        window=self.pyloid.get_window_by_id(request_id),
                     )
                     # 딕셔너리 형태로 params 사용할 때
                     params = params.copy()  # 원본 params 복사
-                    params['ctx'] = ctx
-                
+                    params["ctx"] = ctx
+
                 # Call the function with positional or keyword arguments
                 if isinstance(params, list):
                     # 리스트 형태로 params 사용할 때 처리 필요
                     if has_ctx_param:
-                        ctx = RPCContext(pyloid=self.pyloid, window=self.pyloid.get_window_by_id(request_id))
+                        ctx = RPCContext(
+                            pyloid=self.pyloid,
+                            window=self.pyloid.get_window_by_id(request_id),
+                        )
                         result = await func(ctx, *params, request_id=request_id)
                     else:
                         result = await func(*params, request_id=request_id)
                 else:  # isinstance(params, dict)
                     internal_window_id = request_id
                     params = params.copy()
-                    params['_pyloid_window_id'] = internal_window_id
+                    params["_pyloid_window_id"] = internal_window_id
 
                     # 함수 시그니처에 맞는 인자만 추려서 전달
                     sig = inspect.signature(func)
                     allowed_params = set(sig.parameters.keys())
-                    filtered_params = {k: v for k, v in params.items() if k in allowed_params}
+                    filtered_params = {
+                        k: v for k, v in params.items() if k in allowed_params
+                    }
                     result = await func(**filtered_params)
 
                 # 5. Format Success Response (only for non-notification requests)
-                if request_id is not None: # Notifications (id=null or absent) don't get responses
-                    response_data = {"jsonrpc": "2.0", "result": result, "id": request_id}
+                if (
+                    request_id is not None
+                ):  # Notifications (id=null or absent) don't get responses
+                    response_data = {
+                        "jsonrpc": "2.0",
+                        "result": result,
+                        "id": request_id,
+                    }
                     return web.json_response(response_data)
                 else:
                     # No response for notifications, return 204 No Content might be appropriate
@@ -357,32 +424,57 @@ class PyloidRPC:
                     # For clarity/standard compliance, maybe return 204?
                     return web.Response(status=204)
 
-
             except RPCError as e:
-                 # Application-specific error during method execution
-                 log.warning(f"RPC execution error in method '{method_name}': {e}", exc_info=False)
-                 if request_id is not None:
-                     error_resp = {"jsonrpc": "2.0", "error": e.to_dict(), "id": request_id}
-                     # Use 500 or a more specific 4xx/5xx if applicable based on error code?
-                     # Sticking to 500 for server-side execution errors.
-                     return web.json_response(error_resp, status=500)
-                 else:
-                     return web.Response(status=204) # No response for notification errors
+                # Application-specific error during method execution
+                log.warning(
+                    f"RPC execution error in method '{method_name}': {e}",
+                    exc_info=False,
+                )
+                if request_id is not None:
+                    error_resp = {
+                        "jsonrpc": "2.0",
+                        "error": e.to_dict(),
+                        "id": request_id,
+                    }
+                    # Use 500 or a more specific 4xx/5xx if applicable based on error code?
+                    # Sticking to 500 for server-side execution errors.
+                    return web.json_response(error_resp, status=500)
+                else:
+                    return web.Response(
+                        status=204
+                    )  # No response for notification errors
             except Exception as e:
                 # Unexpected error during method execution
-                log.exception(f"Unexpected error during execution of RPC method '{method_name}':") # Log full traceback
+                log.exception(
+                    f"Unexpected error during execution of RPC method '{method_name}':"
+                )  # Log full traceback
                 if request_id is not None:
                     # Minimize internal details exposed to the client
-                    error_resp = {"jsonrpc": "2.0", "error": {"code": -32000, "message": f"Server error: {type(e).__name__}"}, "id": request_id}
-                    return web.json_response(error_resp, status=500) # Internal Server Error
+                    error_resp = {
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32000,
+                            "message": f"Server error: {type(e).__name__}",
+                        },
+                        "id": request_id,
+                    }
+                    return web.json_response(
+                        error_resp, status=500
+                    )  # Internal Server Error
                 else:
-                    return web.Response(status=204) # No response for notification errors
+                    return web.Response(
+                        status=204
+                    )  # No response for notification errors
 
         except Exception as e:
             # Catch-all for fatal errors during request handling itself (before/after method call)
             log.exception("Fatal error in RPC handler:")
             # ID might be uncertain at this stage, include if available
-            error_resp = {"jsonrpc": "2.0", "error": {"code": -32603, "message": "Internal error"}, "id": request_id}
+            error_resp = {
+                "jsonrpc": "2.0",
+                "error": {"code": -32603, "message": "Internal error"},
+                "id": request_id,
+            }
             return web.json_response(error_resp, status=500)
 
     async def start_async(self, **kwargs):
@@ -419,10 +511,10 @@ class PyloidRPC:
         """
         log.info(f"Starting RPC server")
         # Default to print=None to avoid duplicate startup messages, can be overridden via kwargs
-        run_app_kwargs = {'print': None, 'access_log': None}
+        run_app_kwargs = {"print": None, "access_log": None}
         run_app_kwargs.update(kwargs)
         try:
             web.run_app(self._app, host=self._host, port=self._port, **run_app_kwargs)
         except Exception as e:
             log.exception(f"Failed to start or run the server: {e}")
-            raise
+            raise

{pyloid-0.24.4.dev0.dist-info → pyloid-0.24.6.dist-info}/LICENSE

@@ -198,4 +198,4 @@ Apache License
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

{pyloid-0.24.4.dev0.dist-info → pyloid-0.24.6.dist-info}/METADATA

@@ -1,19 +1,20 @@
 Metadata-Version: 2.3
 Name: pyloid
-Version: 0.24.4.dev0
+Version: 0.24.6
 Summary: 
 Author: aesthetics-of-record
 Author-email: 111675679+aesthetics-of-record@users.noreply.github.com
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9,<3.14
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiohttp-cors (>=0.8.1,<0.9.0)
 Requires-Dist: pickledb (>=1.3.2,<2.0.0)
 Requires-Dist: platformdirs (>=4.3.7,<5.0.0)
-Requires-Dist: pyside6 (==6.8.0)
+Requires-Dist: pyside6 (==6.8.3)
 Description-Content-Type: text/markdown
 
 <h1 style="text-align: center; font-size: 200px; font-weight: 500;">

{pyloid-0.24.4.dev0.dist-info → pyloid-0.24.6.dist-info}/RECORD

@@ -1,15 +1,15 @@
 pyloid/__init__.py,sha256=YKwMCSOds1QVi9N7EGfY0Z7BEjJn8j6HGqRblZlZClA,235
 pyloid/api.py,sha256=A61Kmddh8BlpT3LfA6NbPQNzFmD95vQ4WKX53oKsGYU,2419
 pyloid/autostart.py,sha256=K7DQYl4LHItvPp0bt1V9WwaaZmVSTeGvadkcwG-KKrI,3899
-pyloid/browser_window.py,sha256=-tXG3zUFBliYo-vOb3pSiZ5uABnjC5wtOPzT7PoXnY4,101317
+pyloid/browser_window.py,sha256=EkYcqwdX_WC2woIUcElwI7E4BgpXk_a_hgJJcDS1vc4,104226
 pyloid/custom/titlebar.py,sha256=itzK9pJbZMQ7BKca9kdbuHMffurrw15UijR6OU03Xsk,3894
 pyloid/filewatcher.py,sha256=3M5zWVUf1OhlkWJcDFC8ZA9agO4Q-U8WdgGpy6kaVz0,4601
 pyloid/js_api/base.py,sha256=Z3ID-4AJ0eHusmljRltlSaK4m2RKvRNfmqX76NLF77o,8585
 pyloid/js_api/event_api.py,sha256=w0z1DcmwcmseqfcoZWgsQmFC2iBCgTMVJubTaHeXI1c,957
 pyloid/js_api/window_api.py,sha256=-isphU3m2wGB5U0yZrSuK_4XiBz2mG45HsjYTUq7Fxs,7348
 pyloid/monitor.py,sha256=1mXvHm5deohnNlTLcRx4sT4x-stnOIb0dUQnnxN50Uo,28295
-pyloid/pyloid.py,sha256=y3kHGahvNkJ_4vMESBVHh1j3OU9foM4GLQF2MID3Vhg,84099
-pyloid/rpc.py,sha256=U3G6d5VgCibT0XwSX6eNhLePNyUG8ejfJSf8F43zBpk,18601
+pyloid/pyloid.py,sha256=DSHpMRDW4WvZgAAo2nJMesMJuOkNTVEEsDhCFIvjB5w,84509
+pyloid/rpc.py,sha256=OnF1sRGok9OJ-Q5519eQARD4oZTohyPhsPAT2Mg4_Gg,20377
 pyloid/serve.py,sha256=wJIBqiLr1-8FvBdV3yybeBtVXsu94FfWYKjHL0eQ68s,1444
 pyloid/store.py,sha256=teoa-HYzwm93Rivcw3AhKw6rAmQqQ_kmF6XYSkC3G_I,4541
 pyloid/thread_pool.py,sha256=fKOBb8jMfZn_7crA_fJCno8dObBRZE31EIWaNQ759aw,14616
@@ -17,7 +17,7 @@ pyloid/timer.py,sha256=RqMsChFUd93cxMVgkHWiIKrci0QDTBgJSTULnAtYT8M,8712
 pyloid/tray.py,sha256=D12opVEc2wc2T4tK9epaN1oOdeziScsIVNM2uCN7C-A,1710
 pyloid/url_interceptor.py,sha256=AFjPANDELc9-E-1TnVvkNVc-JZBJYf0677dWQ8LDaqw,726
 pyloid/utils.py,sha256=J6owgVE1YDOEfcOPmoP9m9Q6nbYDyNEo9uqPsJs5p5g,6644
-pyloid-0.24.4.dev0.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
-pyloid-0.24.4.dev0.dist-info/METADATA,sha256=Kh9etxF0hhZKZoR3rm3_ekwVftvLmr78E0gR2h4sfWM,2158
-pyloid-0.24.4.dev0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pyloid-0.24.4.dev0.dist-info/RECORD,,
+pyloid-0.24.6.dist-info/LICENSE,sha256=MTYF-6xpRekyTUglRweWtbfbwBL1I_3Bgfbm_SNOuI8,11525
+pyloid-0.24.6.dist-info/METADATA,sha256=MUdtV5-iru99UsWv46KP_VVAtmFu3f-nP6NAreUTy1g,2204
+pyloid-0.24.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pyloid-0.24.6.dist-info/RECORD,,