soia-client 1.0.20__py3-none-any.whl → 1.0.21__py3-none-any.whl

soia/__init__.py

@@ -8,7 +8,7 @@ from soia._impl.serializers import (
     optional_serializer,
     primitive_serializer,
 )
-from soia._impl.service import RequestHeaders, ResponseHeaders, Service
+from soia._impl.service import RawServiceResponse, Service, ServiceAsync
 from soia._impl.service_client import ServiceClient
 from soia._impl.timestamp import Timestamp
 
@@ -18,10 +18,10 @@ __all__ = [
     "_",
     "KeyedItems",
     "Method",
-    "RequestHeaders",
-    "ResponseHeaders",
+    "RawServiceResponse",
     "Serializer",
     "Service",
+    "ServiceAsync",
     "ServiceClient",
     "Timestamp",
     "array_serializer",

soia/_impl/service.py

@@ -1,7 +1,8 @@
 import inspect
 import json
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Any, Callable, Generic, Literal, TypeVar, Union, cast
+from typing import Any, Generic, Literal, TypeVar, Union, cast
 
 from soia._impl.method import Method, Request, Response
 
@@ -10,42 +11,157 @@ RequestHeaders = TypeVar("RequestHeaders")
 ResponseHeaders = TypeVar("ResponseHeaders")
 
 
-class Service(Generic[RequestHeaders, ResponseHeaders]):
-    """Wraps around the implementation of a soia service on the server side.
+@dataclass(frozen=True)
+class _MethodImpl(Generic[Request, Response, RequestHeaders, ResponseHeaders]):
+    method: Method[Request, Response]
+    impl: Callable[
+        # Parameters
+        [Request, RequestHeaders, ResponseHeaders],
+        # Return type
+        Union[Response, Awaitable[Response]],
+    ]
 
-    Usage: call '.add_method()' to register method implementations, then call
-    '.handle_request()' from the function called by your web framework when an
-    HTTP request is received at your service's endpoint.
 
-    Example with Flask:
+@dataclass(frozen=True)
+class RawServiceResponse:
+    data: str
+    type: Literal["ok-json", "bad-request", "server-error"]
 
-        from flask import Response, request
-        from werkzeug.datastructures import Headers
+    @property
+    def status_code(self):
+        if self.type == "ok-json":
+            return 200
+        elif self.type == "bad-request":
+            return 400
+        elif self.type == "server-error":
+            return 500
+        else:
+            raise TypeError(f"Unknown response type: {self.type}")
 
+    @property
+    def content_type(self):
+        if self.type == "ok-json":
+            return "application/json"
+        elif self.type == "bad-request" or self.type == "server-error":
+            return "text/plain; charset=utf-8"
+        else:
+            raise TypeError(f"Unknown response type: {self.type}")
 
-        s = soia.Service[Headers, Headers]()
-        s.add_method(...)
-        s.add_method(...)
 
-        @app.route("/myapi", methods=["GET", "POST"])
-        def myapi():
-            if request.method == "POST":
-                req_body = request.get_data(as_text=True)
-            else:
-                query_string = request.query_string.decode("utf-8")
-                req_body = urllib.parse.unquote(query_string)
-            req_headers = request.headers
-            res_headers = Headers()
-            raw_response = s.handle_request(req_body, req_headers, res_headers)
-            return Response(
-                raw_response.data,
-                status=raw_response.status_code,
-                content_type=raw_response.content_type,
-                headers=res_headers,
+@dataclass()
+class _HandleRequestFlow(Generic[Request, Response, RequestHeaders, ResponseHeaders]):
+    req_body: str
+    req_headers: RequestHeaders
+    res_headers: ResponseHeaders
+    number_to_method_impl: dict[
+        int, _MethodImpl[Any, Any, RequestHeaders, ResponseHeaders]
+    ]
+    _format: str = ""
+
+    def run(self) -> RawServiceResponse:
+        req_impl_pair_or_raw_response = self._parse_request()
+        if isinstance(req_impl_pair_or_raw_response, RawServiceResponse):
+            return req_impl_pair_or_raw_response
+        req, method_impl = req_impl_pair_or_raw_response
+        try:
+            res = method_impl.impl(req, self.req_headers, self.res_headers)
+        except Exception as e:
+            return RawServiceResponse(f"server error: {e}", "server-error")
+        if inspect.isawaitable(res):
+            raise TypeError("Method implementation must be synchronous")
+        return self._response_to_json(res, method_impl)
+
+    async def run_async(self) -> RawServiceResponse:
+        req_impl_pair_or_raw_response = self._parse_request()
+        if isinstance(req_impl_pair_or_raw_response, RawServiceResponse):
+            return req_impl_pair_or_raw_response
+        req, method_impl = req_impl_pair_or_raw_response
+        try:
+            res: Any = method_impl.impl(req, self.req_headers, self.res_headers)
+            if inspect.isawaitable(res):
+                res = await res
+        except Exception as e:
+            return RawServiceResponse(f"server error: {e}", "server-error")
+        return self._response_to_json(res, method_impl)
+
+    def _parse_request(
+        self,
+    ) -> Union[
+        tuple[Any, _MethodImpl[Request, Response, RequestHeaders, ResponseHeaders]],
+        RawServiceResponse,
+    ]:
+        if self.req_body == "list":
+
+            def method_to_json(method: Method) -> Any:
+                return {
+                    "method": method.name,
+                    "number": method.number,
+                    "request": method.request_serializer.type_descriptor.as_json(),
+                    "response": method.response_serializer.type_descriptor.as_json(),
+                }
+
+            json_code = json.dumps(
+                {
+                    "methods": [
+                        method_to_json(method_impl.method)
+                        for method_impl in self.number_to_method_impl.values()
+                    ]
+                },
+                indent=2,
             )
-    """
+            return RawServiceResponse(json_code, "ok-json")
 
-    _number_to_method_impl: dict[int, "_MethodImpl"]
+        parts = self.req_body.split(":", 3)
+        if len(parts) != 4:
+            return RawServiceResponse(
+                "bad request: invalid request format", "bad-request"
+            )
+        method_name = parts[0]
+        method_number_str = parts[1]
+        self.format = parts[2]
+        request_data = parts[3]
+        try:
+            method_number = int(method_number_str)
+        except Exception:
+            return RawServiceResponse(
+                "bad request: can't parse method number", "bad-request"
+            )
+        method_impl = self.number_to_method_impl.get(method_number)
+        if not method_impl:
+            return RawServiceResponse(
+                f"bad request: method not found: {method_name}; number: {method_number}",
+                "bad-request",
+            )
+        try:
+            req: Any = method_impl.method.request_serializer.from_json_code(
+                request_data
+            )
+        except Exception as e:
+            return RawServiceResponse(
+                f"bad request: can't parse JSON: {e}", "bad-request"
+            )
+        return (req, method_impl)
+
+    def _response_to_json(
+        self,
+        res: Response,
+        method_impl: _MethodImpl[Request, Response, RequestHeaders, ResponseHeaders],
+    ) -> RawServiceResponse:
+        try:
+            res_json = method_impl.method.response_serializer.to_json_code(
+                res, readable=(self.format == "readable")
+            )
+        except Exception as e:
+            return RawServiceResponse(
+                f"server error: can't serialize response to JSON: {e}", "server-error"
+            )
+        return RawServiceResponse(res_json, "ok-json")
+
+
+class _ServiceImpl(Generic[RequestHeaders, ResponseHeaders]):
+    _number_to_method_impl: dict[
+        int, _MethodImpl[Any, Any, RequestHeaders, ResponseHeaders]
+    ]
 
     def __init__(self):
         self._number_to_method_impl = {}
@@ -54,11 +170,16 @@ class Service(Generic[RequestHeaders, ResponseHeaders]):
         self,
         method: Method[Request, Response],
         impl: Union[
+            # Sync
             Callable[[Request], Response],
             Callable[[Request, RequestHeaders], Response],
             Callable[[Request, RequestHeaders, ResponseHeaders], Response],
+            # Async
+            Callable[[Request], Awaitable[Response]],
+            Callable[[Request, RequestHeaders], Awaitable[Response]],
+            Callable[[Request, RequestHeaders, ResponseHeaders], Awaitable[Response]],
         ],
-    ) -> "Service":
+    ) -> None:
         signature = inspect.Signature.from_callable(impl)
         num_positional_params = 0
         for param in signature.parameters.values():
@@ -97,109 +218,122 @@ class Service(Generic[RequestHeaders, ResponseHeaders]):
             method=method,
             impl=resolved_impl,
         )
-        return self
-
-    @dataclass(frozen=True)
-    class RawResponse:
-        data: str
-        type: Literal["ok-json", "bad-request", "server-error"]
-
-        @property
-        def status_code(self):
-            if self.type == "ok-json":
-                return 200
-            elif self.type == "bad-request":
-                return 400
-            elif self.type == "server-error":
-                return 500
-            else:
-                raise TypeError(f"Unknown response type: {self.type}")
-
-        @property
-        def content_type(self):
-            if self.type == "ok-json":
-                return "application/json"
-            elif self.type == "bad-request" or self.type == "server-error":
-                return "text/plain; charset=utf-8"
-            else:
-                raise TypeError(f"Unknown response type: {self.type}")
 
     def handle_request(
         self,
         req_body: str,
         req_headers: RequestHeaders,
         res_headers: ResponseHeaders,
-    ) -> RawResponse:
-        if req_body == "list":
+    ) -> RawServiceResponse:
+        flow = _HandleRequestFlow(
+            req_body=req_body,
+            req_headers=req_headers,
+            res_headers=res_headers,
+            number_to_method_impl=self._number_to_method_impl,
+        )
+        return flow.run()
 
-            def method_to_json(method: Method) -> Any:
-                return {
-                    "method": method.name,
-                    "number": method.number,
-                    "request": method.request_serializer.type_descriptor.as_json(),
-                    "response": method.response_serializer.type_descriptor.as_json(),
-                }
+    async def handle_request_async(
+        self,
+        req_body: str,
+        req_headers: RequestHeaders,
+        res_headers: ResponseHeaders,
+    ) -> RawServiceResponse:
+        flow = _HandleRequestFlow(
+            req_body=req_body,
+            req_headers=req_headers,
+            res_headers=res_headers,
+            number_to_method_impl=self._number_to_method_impl,
+        )
+        return await flow.run_async()
 
-            json_code = json.dumps(
-                {
-                    "methods": [
-                        method_to_json(method_impl.method)
-                        for method_impl in self._number_to_method_impl.values()
-                    ]
-                },
-                indent=2,
-            )
-            return self.RawResponse(json_code, "ok-json")
 
-        parts = req_body.split(":", 3)
-        if len(parts) != 4:
-            return self.RawResponse(
-                "bad request: invalid request format", "bad-request"
-            )
-        method_name = parts[0]
-        method_number_str = parts[1]
-        format = parts[2]
-        request_data = parts[3]
-        try:
-            method_number = int(method_number_str)
-        except Exception:
-            return self.RawResponse(
-                "bad request: can't parse method number", "bad-request"
-            )
-        method_impl = self._number_to_method_impl.get(method_number)
-        if not method_impl:
-            return self.RawResponse(
-                f"bad request: method not found: {method_name}; number: {method_number}",
-                "bad-request",
-            )
+class Service(Generic[RequestHeaders, ResponseHeaders]):
+    """Wraps around the implementation of a soia service on the server side.
 
-        try:
-            req: Any = method_impl.method.request_serializer.from_json_code(
-                request_data
-            )
-        except Exception as e:
-            return self.RawResponse(
-                f"bad request: can't parse JSON: {e}", "bad-request"
-            )
+    Usage: call '.add_method()' to register method implementations, then call
+    '.handle_request()' from the function called by your web framework when an
+    HTTP request is received at your service's endpoint.
 
-        try:
-            res: Any = method_impl.impl(req, req_headers, res_headers)
-        except Exception as e:
-            return self.RawResponse(f"server error: {e}", "server-error")
+    Example with Flask:
 
-        try:
-            res_json = method_impl.method.response_serializer.to_json_code(
-                res, readable=(format == "readable")
-            )
-        except Exception as e:
-            return self.RawResponse(
-                f"server error: can't serialize response to JSON: {e}", "server-error"
+        from flask import Response, request
+        from werkzeug.datastructures import Headers
+
+
+        s = soia.Service[Headers, Headers]()
+        s.add_method(...)
+        s.add_method(...)
+
+        @app.route("/myapi", methods=["GET", "POST"])
+        def myapi():
+            if request.method == "POST":
+                req_body = request.get_data(as_text=True)
+            else:
+                query_string = request.query_string.decode("utf-8")
+                req_body = urllib.parse.unquote(query_string)
+            req_headers = request.headers
+            res_headers = Headers()
+            raw_response = s.handle_request(req_body, req_headers, res_headers)
+            return Response(
+                raw_response.data,
+                status=raw_response.status_code,
+                content_type=raw_response.content_type,
+                headers=res_headers,
             )
+    """
 
-        return self.RawResponse(res_json, "ok-json")
+    _impl: _ServiceImpl[RequestHeaders, ResponseHeaders]
 
+    def __init__(self):
+        self._impl = _ServiceImpl[RequestHeaders, ResponseHeaders]()
 
-@dataclass(frozen=True)
-class _MethodImpl(Generic[Request, Response, RequestHeaders, ResponseHeaders]):
-    method: Method[Request, Response]
-    impl: Callable[[Request, RequestHeaders, ResponseHeaders], Response]
+    def add_method(
+        self,
+        method: Method[Request, Response],
+        impl: Union[
+            Callable[[Request], Response],
+            Callable[[Request, RequestHeaders], Response],
+            Callable[[Request, RequestHeaders, ResponseHeaders], Response],
+        ],
+    ) -> None:
+        self._impl.add_method(method, impl)
+
+    def handle_request(
+        self,
+        req_body: str,
+        req_headers: RequestHeaders,
+        res_headers: ResponseHeaders,
+    ) -> RawServiceResponse:
+        return self._impl.handle_request(req_body, req_headers, res_headers)
+
+
+class ServiceAsync(Generic[RequestHeaders, ResponseHeaders]):
+    _impl: _ServiceImpl[RequestHeaders, ResponseHeaders]
+
+    def __init__(self):
+        self._impl = _ServiceImpl[RequestHeaders, ResponseHeaders]()
+
+    def add_method(
+        self,
+        method: Method[Request, Response],
+        impl: Union[
+            # Sync
+            Callable[[Request], Response],
+            Callable[[Request, RequestHeaders], Response],
+            Callable[[Request, RequestHeaders, ResponseHeaders], Response],
+            # Async
+            Callable[[Request], Awaitable[Response]],
+            Callable[[Request, RequestHeaders], Awaitable[Response]],
+            Callable[[Request, RequestHeaders, ResponseHeaders], Awaitable[Response]],
+        ],
+    ) -> None:
+        self._impl.add_method(method, impl)
+
+    async def handle_request(
+        self,
+        req_body: str,
+        req_headers: RequestHeaders,
+        res_headers: ResponseHeaders,
+    ) -> RawServiceResponse:
+        return await self._impl.handle_request_async(req_body, req_headers, res_headers)

{soia_client-1.0.20.dist-info → soia_client-1.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soia-client
-Version: 1.0.20
+Version: 1.0.21
 Author-email: Tyler Fibonacci <gepheum@gmail.com>
 License: MIT License
         

{soia_client-1.0.20.dist-info → soia_client-1.0.21.dist-info}/RECORD

@@ -1,4 +1,4 @@
-soia/__init__.py,sha256=mI-PNb0RHa0mq4m0e6NKIcQsR8EFkTeKHzh6bVbnRYg,722
+soia/__init__.py,sha256=GFsFZjzbElOC3AJHoaiI_eb3SRXu0-ooE0QXusL-O1k,724
 soia/_module_initializer.py,sha256=1TWnc0qUO7_iljQR2ywVERrrkY5jIkT3zucc-AYZyrQ,4221
 soia/_spec.py,sha256=Y5EHHQa6qNeJc29aaqGrFPnPFXxlL7TED9_AXUGBjf0,3663
 soia/reflection.py,sha256=U5knJGmawARCdcEhNxek4dvx48WLPETLqIqKBPWwT4Q,8771
@@ -14,13 +14,13 @@ soia/_impl/primitives.py,sha256=Xk26Fv4oQG2oXd3tS_2sAnJYQdXYX9nva09713AcJvs,8940
 soia/_impl/repr.py,sha256=7WX0bEAVENTjlyZIcbT8TcJylS7IRIyafGCmqaIMxFM,1413
 soia/_impl/serializer.py,sha256=28IwkjtUnLpbnPQfVNfJXkApCK4JhXHwLkC5MVhF8xo,3529
 soia/_impl/serializers.py,sha256=IL9jHHMo11pgrL1-crarOEElvTyV5YM6FTcgumjW6IU,2564
-soia/_impl/service.py,sha256=GH0vujMDaqRpX8bNQATUPdzJ1V_fjt4eHGCBAjLjlaY,7229
+soia/_impl/service.py,sha256=PsV286BYMoJpXIjeBc__MHHakcqof0Pbb3B_Zha1PZI,11928
 soia/_impl/service_client.py,sha256=qDntwRyXfLsmXl4ELfOkh-fgv553nrGy72K0JghLM80,2734
 soia/_impl/structs.py,sha256=YTc3Ykj2TxPquar2XsP2DhFfkfIoELXOveyd8yTqN90,26545
 soia/_impl/timestamp.py,sha256=lXBNH8mPmzflkNjSKZSBl2XS-ot9N8N92B_zGO2SMtU,4078
 soia/_impl/type_adapter.py,sha256=RyIyh4Fnt9rMy0HRzC-a2v2JAdZsV9FBzoGEUVygVRE,2101
-soia_client-1.0.20.dist-info/licenses/LICENSE,sha256=SaAftKkX6hfSOiPdENQPS70tifH3PDHgazq8eK2Pwfw,1064
-soia_client-1.0.20.dist-info/METADATA,sha256=7HocgiYValsPhLrZnucq5U1m-AIF3aRBQn5RZjXLl0o,2122
-soia_client-1.0.20.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
-soia_client-1.0.20.dist-info/top_level.txt,sha256=lsYG9JrvauFe1oIV5zvnwsS9hsx3ztwfK_937op9mxc,5
-soia_client-1.0.20.dist-info/RECORD,,
+soia_client-1.0.21.dist-info/licenses/LICENSE,sha256=SaAftKkX6hfSOiPdENQPS70tifH3PDHgazq8eK2Pwfw,1064
+soia_client-1.0.21.dist-info/METADATA,sha256=Ru0EEbE4aLijjzYSjeaCuC3WImJuTYL0HfxpqaL8KFc,2122
+soia_client-1.0.21.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+soia_client-1.0.21.dist-info/top_level.txt,sha256=lsYG9JrvauFe1oIV5zvnwsS9hsx3ztwfK_937op9mxc,5
+soia_client-1.0.21.dist-info/RECORD,,

{soia_client-1.0.20.dist-info → soia_client-1.0.21.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any