pyloid 0.22.1__py3-none-any.whl → 0.23.1__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.1.dist-info → pyloid-0.23.1.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.22.1.dist-info → pyloid-0.23.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyloid
-Version: 0.22.1
+Version: 0.23.1
 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.1.dist-info → pyloid-0.23.1.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=Bf0rtdOsZb6fM55xQkDQQfdDATashnVlRYvGPM93X0M,99696
 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=KKAdAifbDVo247NNTsvvdGob0mi4QTtfewNFnOZadQo,72964
+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.1.dist-info/LICENSE,sha256=MTYF-6xpRekyTUglRweWtbfbwBL1I_3Bgfbm_SNOuI8,11525
-pyloid-0.22.1.dist-info/METADATA,sha256=Ing9aadKgH6AOvjuRJhc_-P9hpLGOXF8WVZjLU4jt5g,3066
-pyloid-0.22.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pyloid-0.22.1.dist-info/RECORD,,
+pyloid-0.23.1.dist-info/LICENSE,sha256=F96EzotgWhhpnQTW2TcdoqrMDir1jyEo6H915tGQ-QE,11524
+pyloid-0.23.1.dist-info/METADATA,sha256=I6lKViC1XGADQp_MuuZKr86kUEzHsgHU8jjZ7IeAb7k,3197
+pyloid-0.23.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pyloid-0.23.1.dist-info/RECORD,,