file handler and error handling

Author: aplr

lf_toolkit/__init__.py

@@ -1,10 +1,11 @@
 import importlib.metadata as importlib_metadata
 
-from .rpc import IPCServer
-from .rpc import StdioServer
-from .rpc import create_server
-from .rpc import run
-from .rpc import serve
+from .io import FileServer
+from .io import IPCServer
+from .io import StdioServer
+from .io import create_server
+from .io import run
+from .io import serve
 
 
 __version__ = importlib_metadata.version("lf_toolkit")

lf_toolkit/evaluation/__init__.py

@@ -1,3 +1,3 @@
-from ..internal.models import Params
-from ..internal.models import SymbolDict
+from ..shared import Params
+from ..shared import SymbolDict
 from .result import Result

lf_toolkit/internal/__init__.py

@@ -1,5 +1,5 @@
+from .file_server import FileServer
 from .ipc_server import IPCServer
 from .serve import create_server
 from .serve import run
-from .serve import serve
 from .stdio_server import StdioServer

lf_toolkit/rpc/__init__.py lf_toolkit/io/__init__.pylf_toolkit/rpc/__init__.py renamed to lf_toolkit/io/__init__.py

@@ -0,0 +1,53 @@
+from abc import ABC
+from abc import abstractmethod
+from functools import wraps
+from typing import Any
+from typing import Awaitable
+from typing import Callable
+from typing import Optional
+from typing import Union
+
+from ..evaluation import Result as EvaluationResult
+from ..preview import Result as PreviewResult
+from ..shared import Params
+from .handler import Handler
+from .handler import JsonRpcHandler
+
+
+EvaluationFunction = Callable[
+    [Any, Any, Params], Union[EvaluationResult, Awaitable[EvaluationResult]]
+]
+
+PreviewFunction = Callable[
+    [Any, Params], Union[PreviewResult, Awaitable[PreviewResult]]
+]
+
+
+class BaseServer(ABC):
+
+    _handler: Handler
+
+    def __init__(self, handler: Optional[Handler] = None):
+        self._handler = handler if handler is not None else JsonRpcHandler()
+
+    @abstractmethod
+    async def run(self):
+        pass
+
+    async def dispatch(self, req: str) -> str:
+        return await self._handler.dispatch(req)
+
+    def eval(self, fn: EvaluationFunction):
+        return handler_decorator(self._handler, "eval", fn)
+
+    def preview(self, fn: PreviewFunction):
+        return handler_decorator(self._handler, "preview", fn)
+
+
+def handler_decorator(registry: Handler, name: str, fn):
+    @wraps(fn)
+    def decorator():
+        registry.register(name, fn)
+        return fn
+
+    return decorator()

lf_toolkit/io/base_server.py

@@ -0,0 +1,46 @@
+from typing import Optional
+
+import ujson
+
+from anyio import open_file
+
+from .base_server import BaseServer
+from .handler import Handler
+
+
+class FileHandler(Handler):
+
+    async def dispatch(self, req: str) -> str:
+        request = ujson.loads(req)
+        command = request.get("command", None)
+        try:
+            result = await self.handle(command, request)
+            response = {"command": command, "result": result}
+        except Exception as e:
+            response = {"command": command, "error": str(e)}
+        return ujson.dumps(response)
+
+
+class FileServer(BaseServer):
+
+    _request_file_path: str
+    _response_file_path: str
+
+    def __init__(
+        self,
+        request_file_path: str,
+        response_file_path: str,
+        handler: Optional[Handler] = None,
+    ):
+        super().__init__(handler if handler is not None else FileHandler())
+        self._request_file_path = request_file_path
+        self._response_file_path = response_file_path
+
+    async def run(self):
+        async with await open_file(self._request_file_path, "r") as f:
+            request = await f.read()
+
+        response = await self.dispatch(request)
+
+        async with await open_file(self._response_file_path, "w") as f:
+            await f.write(response)

lf_toolkit/io/file_server.py

@@ -0,0 +1,64 @@
+import asyncio
+
+from abc import ABC
+from abc import abstractmethod
+from typing import Callable
+from typing import Dict
+
+import anyio
+
+from ..evaluation import Result as EvaluationResult
+from ..shared import Command
+from ..shared import Params
+
+
+class Handler(ABC):
+
+    _handlers: Dict[str, Callable] = {}
+
+    @abstractmethod
+    async def dispatch(self, req: str) -> str:
+        pass
+
+    def register(self, name: str, fn: Callable):
+        self._handlers[name] = fn
+
+    async def _call_user_handler(self, req: str, *args, **kwargs):
+        handler = self._handlers.get(req)
+
+        if handler is None:
+            raise ValueError(f"No user handler for '{req}'")
+
+        try:
+            if asyncio.iscoroutinefunction(handler):
+                return await handler(*args, **kwargs)
+            else:
+                return await anyio.to_thread.run_sync(handler, *args, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error calling user handler for '{req}': {e}")
+
+    async def handle_eval(self, req: dict):
+        response = req.get("response", None)
+        answer = req.get("answer", None)
+        params = Params(req.get("params", {}))
+
+        return await self._call_user_handler("eval", response, answer, params)
+
+    async def handle_preview(self, req: dict):
+        response = req.get("response", None)
+        params = Params(req.get("params", {}))
+
+        result = await self._call_user_handler("preview", response, params)
+
+        if isinstance(result, EvaluationResult):
+            return result.to_dict()
+
+        return result
+
+    async def handle(self, name: Command, req: dict) -> dict:
+        handler = getattr(self, f"handle_{name}", None)
+
+        if handler is None:
+            raise ValueError(f"No handler for '{name}'")
+
+        return await handler(req)

lf_toolkit/io/handler.py

@@ -22,7 +22,7 @@ async def listen(self) -> AsyncGenerator[IPCClient, None]:
             while True:
                 try:
                     stream = await listener.accept()
-                    print("Client connected")
+                    # print("Client connected")
                     yield SocketClient(stream)
                 except Exception as e:
                     print(f"Exception: {e}")