pyloid 0.22.0.dev6__py3-none-any.whl → 0.23.0__py3-none-any.whl

pyloid/rpc.py

@@ -0,0 +1,339 @@
+import asyncio
+import json
+import logging
+from functools import wraps
+from typing import Any, Callable, Coroutine, Dict, List, Optional, Union
+from .utils import get_free_port
+from aiohttp import web
+import threading
+import time
+import aiohttp_cors  # CORS 지원을 위한 패키지 추가
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger("pyloid.rpc")
+
+class RPCError(Exception):
+    """
+    Custom exception for RPC-related errors.
+
+    Follows the JSON-RPC 2.0 error object structure.
+
+    Attributes
+    ----------
+    message : str
+        A human-readable description of the error.
+    code : int, optional
+        A number indicating the error type that occurred. Standard JSON-RPC
+        codes are used where applicable, with application-specific codes
+        also possible. Defaults to -32000 (Server error).
+    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.
+
+        Parameters
+        ----------
+        message : str
+            The error message.
+        code : int, optional
+            The error code. Defaults to -32000.
+        data : Any, optional
+            Additional data associated with the error. Defaults to None.
+        """
+        self.message = message
+        self.code = code
+        self.data = data
+        super().__init__(self.message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the error details into a dictionary suitable for JSON-RPC responses.
+
+        Returns
+        -------
+        Dict[str, Any]
+            A dictionary representing the JSON-RPC error object.
+        """
+        error_obj = {"code": self.code, "message": self.message}
+        if self.data is not None:
+            error_obj["data"] = self.data
+        return error_obj
+
+class PyloidRPC:
+    """
+    A simple JSON-RPC server wrapper based on aiohttp.
+
+    Allows registering asynchronous functions as RPC methods using the `@rpc`
+    decorator and handles JSON-RPC 2.0 request parsing, validation,
+    method dispatching, and response formatting.
+
+    Attributes
+    ----------
+    _host : str
+        The hostname or IP address to bind the server to.
+    _port : int
+        The port number to listen on.
+    _rpc_path : str
+        The URL path for handling RPC requests.
+    _functions : Dict[str, Callable[..., Coroutine[Any, Any, Any]]]
+        A dictionary mapping registered RPC method names to their
+        corresponding asynchronous functions.
+    _app : web.Application
+        The underlying aiohttp web application instance.
+    """
+    def __init__(self):
+        """
+        Initialize the PyloidRPC server instance.
+        """
+        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()
+        
+        # CORS 설정 추가
+        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
+
+    def rpc(self, name: Optional[str] = None) -> Callable:
+        """
+        Decorator to register an async function as an RPC method.
+
+        Parameters
+        ----------
+        name : Optional[str], optional
+            The name to register the RPC method under. If None, the
+            function's name is used. Defaults to None.
+
+        Returns
+        -------
+        Callable
+            The decorator function.
+
+        Raises
+        ------
+        TypeError
+            If the decorated function is not an async function (`coroutinefunction`).
+        ValueError
+            If an RPC function with the specified name is already registered.
+        """
+        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.")
+
+            self._functions[rpc_name] = func
+            log.info(f"RPC function registered: {rpc_name}")
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                 # This wrapper exists to follow the decorator pattern.
+                 # The actual call uses the original function stored in _functions.
+                return await func(*args, **kwargs)
+            return wrapper
+        return decorator
+
+    def _validate_jsonrpc_request(self, data: Any) -> Optional[Dict[str, Any]]:
+        """
+        Validate the structure of a potential JSON-RPC request object.
+
+        Checks for required fields ('jsonrpc', 'method') and validates the
+        types of fields like 'params' and 'id' according to the JSON-RPC 2.0 spec.
+
+        Parameters
+        ----------
+        data : Any
+            The parsed JSON data from the request body.
+
+        Returns
+        -------
+        Optional[Dict[str, Any]]
+            None if the request is valid according to the basic structure,
+            otherwise a dictionary representing the JSON-RPC error object
+            to be returned to the client.
+        """
+        # Attempt to extract the ID if possible, even for invalid requests
+        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."}
+        if data.get("jsonrpc") != "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."}
+        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."}
+        # 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
+
+    async def _handle_rpc(self, request: web.Request) -> web.Response:
+        """
+        Handles incoming JSON-RPC requests.
+
+        Parses the request, validates it, dispatches to the appropriate
+        registered RPC method, executes the method, and returns the
+        JSON-RPC response or error object.
+
+        Parameters
+        ----------
+        request : web.Request
+            The incoming aiohttp request object.
+
+        Returns
+        -------
+        web.Response
+            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
+
+        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
+
+            # 2. Parse JSON Body
+            try:
+                raw_data = await request.read()
+                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
+            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
+
+            # 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
+
+            # Assuming validation passed, data is a dict with 'method'
+            method_name: str = data["method"]
+            # Use empty list/dict if 'params' is omitted, as per spec flexibility
+            params: Union[List, Dict] = data.get("params", [])
+
+            # 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
+
+            try:
+                log.debug(f"Executing RPC method: {method_name}(params={params})")
+                # Call the function with positional or keyword arguments
+                if isinstance(params, list):
+                    result = await func(*params)
+                else: # isinstance(params, dict)
+                    result = await func(**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}
+                    return web.json_response(response_data)
+                else:
+                    # No response for notifications, return 204 No Content might be appropriate
+                    # or just an empty response. aiohttp handles this implicitly if nothing is returned.
+                    # 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
+            except Exception as e:
+                # Unexpected error during method execution
+                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
+                else:
+                    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}
+            return web.json_response(error_resp, status=500)
+
+    async def start_async(self, **kwargs):
+        """Starts the server asynchronously without blocking."""
+        self._runner = web.AppRunner(self._app, access_log=None, **kwargs)
+        await self._runner.setup()
+        self._site = web.TCPSite(self._runner, self._host, self._port)
+        await self._site.start()
+        log.info(f"RPC server started asynchronously on {self.url}")
+        # 서버가 백그라운드에서 실행되도록 여기서 블로킹하지 않습니다.
+        # 이 코루틴은 서버 시작 후 즉시 반환됩니다.
+
+    async def stop_async(self):
+        """Stops the server asynchronously."""
+        if self._runner:
+            await self._runner.cleanup()
+            log.info("RPC server stopped.")
+        self._site = None
+        self._runner = None
+
+    def start(self, **kwargs):
+        """
+        Start the aiohttp web server to listen for RPC requests (blocking).
+
+        This method wraps `aiohttp.web.run_app` and blocks until the server stops.
+        Prefer `start_async` for non-blocking operation within an asyncio event loop.
+
+        Parameters
+        ----------
+        **kwargs
+            Additional keyword arguments to pass directly to `aiohttp.web.run_app`.
+            For example, `ssl_context` for HTTPS. By default, suppresses the
+            default `aiohttp` startup message using `print=None`.
+        """
+        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.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

pyloid/store.py

@@ -0,0 +1,172 @@
+from pickledb import PickleDB
+from typing import Any, List, Optional
+
+
+class Store:
+    def __init__(self, path: str):
+        """
+        Initialize a Store instance.
+
+        Parameters
+        ----------
+        path: str
+            Path to the database file where data will be stored
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        """
+        self.db = PickleDB(path)
+
+    def get(self, key: str) -> Any:
+        """
+        Retrieve the value associated with the specified key.
+
+        Parameters
+        ----------
+        key: str
+            The key to look up in the database
+
+        Returns
+        -------
+        Any
+            The value associated with the key, or None if the key doesn't exist
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        >>> store.set("user", {"name": "John Doe", "age": 30})
+        True
+        >>> user = store.get("user")
+        >>> print(user)
+        {'name': 'John Doe', 'age': 30}
+        >>> print(store.get("non_existent_key"))
+        None
+        """
+        return self.db.get(key)
+
+    def set(self, key: str, value: Any) -> bool:
+        """
+        Add or update a key-value pair in the database.
+
+        Parameters
+        ----------
+        key: str
+            The key to set in the database
+        value: Any
+            The value to associate with the key (must be a JSON-serializable Python data type)
+
+        Returns
+        -------
+        bool
+            Always returns True to indicate the operation was performed
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        >>> store.set("settings", {"theme": "dark", "notifications": True})
+        True
+        >>> store.set("counter", 42)
+        True
+        >>> store.set("items", ["apple", "banana", "orange"])
+        True
+        """
+        return self.db.set(key, value)
+
+    def remove(self, key: str) -> bool:
+        """
+        Delete the value associated with the key from the database.
+
+        Parameters
+        ----------
+        key: str
+            The key to remove from the database
+
+        Returns
+        -------
+        bool
+            True if the key was deleted, False if the key didn't exist
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        >>> store.set("temp", "temporary data")
+        True
+        >>> store.remove("temp")
+        True
+        >>> store.remove("non_existent_key")
+        False
+        """
+        return self.db.remove(key)
+
+    def all(self) -> List[str]:
+        """
+        Retrieve a list of all keys in the database.
+
+        Returns
+        -------
+        List[str]
+            A list containing all keys currently stored in the database
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        >>> store.set("key1", "value1")
+        True
+        >>> store.set("key2", "value2")
+        True
+        >>> keys = store.all()
+        >>> print(keys)
+        ['key1', 'key2']
+        """
+        return self.db.all()
+
+    def purge(self) -> bool:
+        """
+        Clear all keys and values from the database.
+
+        Returns
+        -------
+        bool
+            Always returns True to indicate the operation was performed
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        >>> store.set("key1", "value1")
+        True
+        >>> store.set("key2", "value2")
+        True
+        >>> store.purge()
+        True
+        >>> print(store.all())
+        []
+        """
+        return self.db.purge()
+
+    def save(self, option: Optional[int] = None) -> bool:
+        """
+        Save the current state of the database to file.
+
+        Parameters
+        ----------
+        option: Optional[int]
+            Optional orjson.OPT_* flags that configure serialization behavior.
+            These flags can control formatting, special type handling, etc.
+
+        Returns
+        -------
+        bool
+            True if the operation was successful, False otherwise
+
+        Examples
+        --------
+        >>> store = Store("data.json")
+        >>> store.set("key", "value")
+        True
+        >>> store.save()
+        True
+        """
+        if option is not None:
+            return self.db.save(option)
+        return self.db.save()

pyloid/url_interceptor.py

@@ -0,0 +1,24 @@
+from PySide6.QtWebEngineCore import QWebEngineUrlRequestInterceptor
+from PySide6.QtCore import QUrl
+from typing import Optional
+
+# interceptor ( all url request )
+class CustomUrlInterceptor(QWebEngineUrlRequestInterceptor):
+    def __init__(self, rpc_url: Optional[str] = None):
+        super().__init__()
+        self.rpc_url = rpc_url
+
+    def interceptRequest(self, info):
+        host = info.requestUrl().host()
+        url = info.requestUrl().toString()
+
+        server_url = self.rpc_url
+        
+        if self.rpc_url is None:
+            return
+        
+        if url.startswith(self.rpc_url):
+            return
+
+        if host == "pyloid.rpc":
+            info.redirect(QUrl(server_url))

{pyloid-0.22.0.dev6.dist-info → pyloid-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyloid
-Version: 0.22.0.dev6
+Version: 0.23.0
 Summary: 
 Author: aesthetics-of-record
 Author-email: 111675679+aesthetics-of-record@users.noreply.github.com
@@ -11,6 +11,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.2.1,<7.0.0.0)
 Description-Content-Type: text/markdown
 

{pyloid-0.22.0.dev6.dist-info → pyloid-0.23.0.dist-info}/RECORD

@@ -1,20 +1,23 @@
 pyloid/__init__.py,sha256=4xh7DHBMw2ciDFwI376xcIArhH8GaM4K_NdIa3N0BFo,335
 pyloid/api.py,sha256=A61Kmddh8BlpT3LfA6NbPQNzFmD95vQ4WKX53oKsGYU,2419
 pyloid/autostart.py,sha256=K7DQYl4LHItvPp0bt1V9WwaaZmVSTeGvadkcwG-KKrI,3899
-pyloid/browser_window.py,sha256=jPvx1EPq3VAKwtMnr9wL9FrmQJLz9rIUfP4I8B2BKwQ,99056
+pyloid/browser_window.py,sha256=mQhdMOK7iHSer_rgewDuxEXXF4CrNs4TVt-OQ7YJDTs,99591
 pyloid/custom/titlebar.py,sha256=itzK9pJbZMQ7BKca9kdbuHMffurrw15UijR6OU03Xsk,3894
 pyloid/filewatcher.py,sha256=3M5zWVUf1OhlkWJcDFC8ZA9agO4Q-U8WdgGpy6kaVz0,4601
-pyloid/js_api/base.py,sha256=v2Su9errEY4oBRSXmLZps8dn9qCGbEqwp-hs-MduQRc,826
+pyloid/js_api/base.py,sha256=T7znBDwUwGduHEt--F6eKQwdXPcJsMrMjBs7Z1XVrPE,8255
 pyloid/js_api/event_api.py,sha256=w0z1DcmwcmseqfcoZWgsQmFC2iBCgTMVJubTaHeXI1c,957
-pyloid/js_api/window_api.py,sha256=YnnniHEBGO1qfyziQiJ5ssYOTUxaHe3Wqj1sUZZdem0,8939
+pyloid/js_api/window_api.py,sha256=-isphU3m2wGB5U0yZrSuK_4XiBz2mG45HsjYTUq7Fxs,7348
 pyloid/monitor.py,sha256=1mXvHm5deohnNlTLcRx4sT4x-stnOIb0dUQnnxN50Uo,28295
-pyloid/pyloid.py,sha256=Vt42dQ9r-81QBYiSj1gtYuMiKaK8n-6osfTjITJCtTI,72400
+pyloid/pyloid.py,sha256=bsD5KgEIK1uApJQHkobljlY8wBkCTCiebV2mVE6MudM,85566
+pyloid/rpc.py,sha256=ATGIPZnONRNyVXQN27h4j4dbzWWKvr9tJOwHHs501q0,15115
 pyloid/serve.py,sha256=wJIBqiLr1-8FvBdV3yybeBtVXsu94FfWYKjHL0eQ68s,1444
+pyloid/store.py,sha256=p0plJj52hQjjtNMVJhy20eNLXfQ3Qmf7LtGHQk7FiPg,4471
 pyloid/thread_pool.py,sha256=fKOBb8jMfZn_7crA_fJCno8dObBRZE31EIWaNQ759aw,14616
 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=e866N9uyAGHTMYsqRYY4JL0AEMRCOiY-k1c1zmEpDA4,4686
-pyloid-0.22.0.dev6.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
-pyloid-0.22.0.dev6.dist-info/METADATA,sha256=f93FMF_BmVdqrdp49aC_GE0dWo1-76qsA8c_NqTdfIY,3071
-pyloid-0.22.0.dev6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pyloid-0.22.0.dev6.dist-info/RECORD,,
+pyloid-0.23.0.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
+pyloid-0.23.0.dist-info/METADATA,sha256=jkOxOCerLMGqkVGHmye1m8v-TOSugHqxYycC3C3rTHU,3197
+pyloid-0.23.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pyloid-0.23.0.dist-info/RECORD,,