aspyx-service 0.9.0__py3-none-any.whl

aspyx_service/restchannel.py

@@ -0,0 +1,199 @@
+import inspect
+import re
+from dataclasses import is_dataclass, asdict
+
+from typing import get_type_hints, TypeVar, Annotated, Callable, get_origin, get_args, Type
+
+from pydantic import BaseModel
+
+from aspyx.reflection import DynamicProxy, Decorators
+from .service import RemoteServiceException, ServiceException, channel
+
+T = TypeVar("T")
+
+from .channels import HTTPXChannel
+
+class BodyMarker:
+    pass
+
+Body = lambda t: Annotated[t, BodyMarker]
+
+class QueryParamMarker:
+    pass
+
+QueryParam = lambda t: Annotated[t, QueryParamMarker]
+
+# decorators
+
+def rest(url):
+    def decorator(cls):
+        Decorators.add(cls, rest, url)
+
+        return cls
+    return decorator
+
+def get(url):
+    def decorator(cls):
+        Decorators.add(cls, get, url)
+
+        return cls
+    return decorator
+
+
+def post(url):
+    def decorator(cls):
+        Decorators.add(cls, post, url)
+
+        return cls
+
+    return decorator
+
+def put(url):
+    def decorator(cls):
+        Decorators.add(cls, put, url)
+
+        return cls
+
+    return decorator
+
+def delete(url):
+    def decorator(cls):
+        Decorators.add(cls, delete, url)
+
+        return cls
+
+    return decorator
+
+def patch(url):
+    def decorator(cls):
+        Decorators.add(cls, patch, url)
+
+        return cls
+
+    return decorator
+
+
+
+
+@channel("rest")
+class RestChannel(HTTPXChannel):
+    __slots__ = [
+        "signature",
+        "url_template",
+        "type",
+        "return_type",
+        "path_param_names",
+        "query_param_names",
+        "body_param_name"
+    ]
+    # local class
+
+    class Call:
+        def __init__(self, type: Type, method : Callable):
+            self.signature = inspect.signature(method)
+
+            prefix = ""
+            if Decorators.has_decorator(type, rest):
+                prefix = Decorators.get_decorator(type, rest).args[0]
+
+            # find decorator
+
+            self.type = "get"
+            self.url_template = ""
+
+            decorators = Decorators.get_all(method)
+
+            for decorator in [get, post, put, delete, patch]:
+                descriptor = next((descriptor for descriptor in decorators if descriptor.decorator is decorator), None)
+                if descriptor is not None:
+                    self.type = decorator.__name__
+                    self.url_template = prefix + descriptor.args[0]
+
+            # parameters
+
+            self.path_param_names = set(re.findall(r"{(.*?)}", self.url_template))
+
+            hints = get_type_hints(method, include_extras=True)
+
+            self.body_param_name = None
+            self.query_param_names = set()
+
+            for param_name, hint in hints.items():
+                if get_origin(hint) is Annotated:
+                    metadata = get_args(hint)[1:]
+                    if BodyMarker in metadata:
+                        self.body_param_name = param_name
+                    elif QueryParamMarker in metadata:
+                        self.query_param_names.add(param_name)
+
+            # return type
+
+            self.return_type = get_type_hints(method)['return']
+
+    # constructor
+
+    def __init__(self):
+        super().__init__("rest")
+
+        self.calls : dict[Callable, RestChannel.Call] = {}
+
+    # internal
+
+    def get_call(self, type: Type ,method: Callable):
+        call = self.calls.get(method, None)
+        if call is None:
+            call = RestChannel.Call(type, method)
+            self.calls[method] = call
+
+        return call
+
+    def to_dict(self, obj):
+        if obj is None:
+            return None
+        if is_dataclass(obj):
+            return asdict(obj)
+        elif isinstance(obj, BaseModel):
+            return obj.dict()
+        elif hasattr(obj, "__dict__"):
+            return vars(obj)
+        else:
+            # fallback for primitives etc.
+            return obj
+
+    # override
+
+    def invoke(self, invocation: DynamicProxy.Invocation):
+        call = self.get_call(invocation.type, invocation.method)
+
+        bound = call.signature.bind(self,*invocation.args, **invocation.kwargs)
+        bound.apply_defaults()
+        arguments = bound.arguments
+
+        # url
+
+        url = call.url_template.format(**arguments)
+        query_params = {k: arguments[k] for k in call.query_param_names if k in arguments}
+        body = {}
+        if call.body_param_name is not None:
+            body = self.to_dict(arguments.get(call.body_param_name))
+
+        # call
+
+        try:
+            if self.client is not None:
+                result = None
+                if call.type == "get":
+                    result = self.client.get(self.get_url() + url, params=query_params, timeout=30000.0).json()
+                elif call.type == "put":
+                    result = self.client.put(self.get_url() + url, params=query_params, timeout=30000.0).json()
+                elif call.type == "delete":
+                    result = self.client.delete(self.get_url() + url, params=query_params, timeout=30000.0).json()
+                elif call.type == "post":
+                    result = self.client.post(self.get_url() + url, params=query_params, json=body, timeout=30000.0).json()
+
+                return self.get_deserializer(invocation.type, invocation.method)(result)
+            else:
+                raise ServiceException(
+                    f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+        except Exception as e:
+            raise ServiceException(f"communication exception {e}") from e

aspyx_service/serialization.py

@@ -0,0 +1,125 @@
+"""
+deserialization functions
+"""
+from dataclasses import is_dataclass, fields
+from functools import lru_cache
+from typing import get_origin, get_args, Union
+
+from pydantic import BaseModel
+
+def deserialize(value, return_type):
+    if value is None:
+        return None
+
+    origin = get_origin(return_type)
+    args = get_args(return_type)
+
+    # Handle Optional / Union
+    if origin is Union and type(None) in args:
+        real_type = [arg for arg in args if arg is not type(None)][0]
+        return deserialize(value, real_type)
+
+    # Handle pydantic
+    if isinstance(return_type, type) and issubclass(return_type, BaseModel):
+        return return_type.parse_obj(value)
+
+    # Handle dataclass
+    if is_dataclass(return_type):
+        return from_dict(return_type, value)
+
+    # Handle List[T]
+    if origin is list:
+        item_type = args[0]
+        return [deserialize(v, item_type) for v in value]
+
+    # Fallback: primitive
+    return value
+
+def from_dict(cls, data: dict):
+    if not is_dataclass(cls):
+        return data  # primitive or unknown
+
+    kwargs = {}
+    for field in fields(cls):
+        name = field.name
+        field_type = field.type
+        value = data.get(name)
+
+        if value is None:
+            kwargs[name] = None
+            continue
+
+        origin = get_origin(field_type)
+        args = get_args(field_type)
+
+        if origin is Union and type(None) in args:
+            real_type = [arg for arg in args if arg is not type(None)][0]
+            kwargs[name] = deserialize(value, real_type)
+
+        elif is_dataclass(field_type):
+            kwargs[name] = from_dict(field_type, value)
+
+        elif origin is list:
+            item_type = args[0]
+            kwargs[name] = [deserialize(v, item_type) for v in value]
+
+        else:
+            kwargs[name] = value
+
+    return cls(**kwargs)
+
+class TypeDeserializer:
+    # constructor
+
+    def __init__(self, typ):
+        self.typ = typ
+        self.deserializer = self._build_deserializer(typ)
+
+    def __call__(self, value):
+        return self.deserializer(value)
+
+    # internal
+
+    def _build_deserializer(self, typ):
+        origin = get_origin(typ)
+        args = get_args(typ)
+
+        if origin is Union:
+            deserializers = [TypeDeserializer(arg) for arg in args if arg is not type(None)]
+            def deser_union(value):
+                if value is None:
+                    return None
+                for d in deserializers:
+                    try:
+                        return d(value)
+                    except Exception:
+                        continue
+                return value
+            return deser_union
+
+        if isinstance(typ, type) and issubclass(typ, BaseModel):
+            return lambda v: typ.parse_obj(v)
+
+        if is_dataclass(typ):
+            field_deserializers = {f.name: TypeDeserializer(f.type) for f in fields(typ)}
+            def deser_dataclass(value):
+                return typ(**{
+                    k: field_deserializers[k](v) for k, v in value.items()
+                })
+            return deser_dataclass
+
+        if origin is list:
+            item_deser = TypeDeserializer(args[0]) if args else lambda x: x
+            return lambda v: [item_deser(item) for item in v]
+
+        if origin is dict:
+            key_deser = TypeDeserializer(args[0]) if args else lambda x: x
+            val_deser = TypeDeserializer(args[1]) if len(args) > 1 else lambda x: x
+            return lambda v: {key_deser(k): val_deser(val) for k, val in v.items()}
+
+        # Fallback
+        return lambda v: v
+
+@lru_cache(maxsize=512)
+def get_deserializer(typ):
+    return TypeDeserializer(typ)

aspyx_service/server.py

@@ -0,0 +1,213 @@
+"""
+FastAPI server implementation for the aspyx service framework.
+"""
+import atexit
+import functools
+import inspect
+import threading
+from typing import Type, Optional, Callable
+
+from fastapi.responses import JSONResponse
+import msgpack
+import uvicorn
+
+from fastapi import FastAPI, APIRouter, Request as HttpRequest, Response as HttpResponse
+
+from aspyx.di import Environment
+from aspyx.reflection import TypeDescriptor, Decorators
+
+from .service import ComponentRegistry
+from .healthcheck import HealthCheckManager
+
+from .serialization import get_deserializer
+
+from .service import Server, ServiceManager
+from .channels import Request, Response
+
+from .restchannel import get, post, put, delete, rest
+
+
+class FastAPIServer(Server):
+    # constructor
+
+    def __init__(self, host="0.0.0.0", port=8000, **kwargs):
+        super().__init__()
+
+        self.host = host
+        Server.port = port
+        self.server_thread = None
+        self.environment : Optional[Environment] = None
+        self.service_manager : Optional[ServiceManager] = None
+        self.component_registry: Optional[ComponentRegistry] = None
+
+        self.router = APIRouter()
+        self.fast_api = FastAPI(host=self.host, port=Server.port, debug=True)
+
+        # cache
+
+        self.deserializers: dict[str, list[Callable]] = {}
+
+        # that's the overall dispatcher
+
+        self.router.post("/invoke")(self.invoke)
+
+    # private
+
+    def add_routes(self):
+        """
+        add everything that looks like a http endpoint
+        """
+
+        # go
+
+        for descriptor in self.service_manager.descriptors.values():
+            if not descriptor.is_component() and descriptor.is_local():
+                prefix = ""
+
+                type_descriptor = TypeDescriptor.for_type(descriptor.type)
+                instance = self.environment.get(descriptor.implementation)
+
+                if type_descriptor.has_decorator(rest):
+                    prefix = type_descriptor.get_decorator(rest).args[0]
+
+                for method in type_descriptor.get_methods():
+                    decorator = next((decorator for decorator in Decorators.get(method.method) if decorator.decorator in [get, put, post, delete]), None)
+                    if decorator is not None:
+                        self.router.add_api_route(
+                            path=prefix + decorator.args[0],
+                            endpoint=getattr(instance, method.get_name()),
+                            methods=[decorator.decorator.__name__],
+                            name=f"{descriptor.get_component_descriptor().name}.{descriptor.name}.{method.get_name()}",
+                            response_model=method.return_type,
+                        )
+
+    def start(self):
+        def run():
+            uvicorn.run(self.fast_api, host=self.host, port=self.port, access_log=False)
+
+        self.server_thread = threading.Thread(target=run, daemon=True)
+        self.server_thread.start()
+
+        print(f"server started on {self.host}:{self.port}")
+
+    def get_deserializers(self, service: Type, method):
+        deserializers = self.deserializers.get(method, None)
+        if deserializers is None:
+            descriptor = TypeDescriptor.for_type(service).get_method(method.__name__)
+
+            deserializers = [get_deserializer(type) for type in descriptor.param_types]
+            self.deserializers[method] = deserializers
+
+        return deserializers
+
+    def deserialize_args(self, request: Request, type: Type, method: Callable) -> list:
+        args = list(request.args)
+
+        deserializers = self.get_deserializers(type, method)
+
+        for i in range(0, len(args)):
+            args[i] = deserializers[i](args[i])
+
+        return args
+
+    async def invoke(self, http_request: HttpRequest):
+        content_type = http_request.headers.get("content-type", "")
+
+        content = "json"
+        if "application/msgpack" in content_type:
+            content = "msgpack"
+            raw_data = await http_request.body()
+            data = msgpack.unpackb(raw_data, raw=False)
+        elif "application/json" in content_type:
+            data = await http_request.json()
+        else:
+            return HttpResponse(
+                content="Unsupported Content-Type",
+                status_code=415,
+                media_type="text/plain"
+            )
+
+        request = Request(**data)
+
+        if content == "json":
+            return await self.dispatch(request)
+        else:
+            return HttpResponse(
+                content=msgpack.packb(await self.dispatch(request), use_bin_type=True),
+                media_type="application/msgpack"
+            )
+
+    async def dispatch(self, request: Request) :
+        ServiceManager.logger.debug("dispatch request %s", request.method)
+
+        # <comp>:<service>:<method>
+
+        parts = request.method.split(":")
+
+        #component = parts[0]
+        service_name = parts[1]
+        method_name = parts[2]
+
+        service_descriptor = ServiceManager.descriptors_by_name[service_name]
+        service = self.service_manager.get_service(service_descriptor.type, preferred_channel="local")
+
+        method = getattr(service, method_name)
+
+        args = self.deserialize_args(request, service_descriptor.type, method)
+        try:
+            if inspect.iscoroutinefunction(method):
+                result = await method(*args)
+            else:
+                result = method(*args)
+
+            return Response(result=result, exception=None).dict()
+        except Exception as e:
+            return Response(result=None, exception=str(e)).dict()
+
+    # override
+
+    def route(self, url: str, callable: Callable):
+        self.router.get(url)(callable)
+
+    def route_health(self, url: str, callable: Callable):
+        async def get_health_response():
+            health : HealthCheckManager.Health = await callable()
+
+            return JSONResponse(
+                status_code= self.component_registry.map_health(health),
+                content = health.to_dict()
+            )
+
+        self.router.get(url)(get_health_response)
+
+    def boot(self, module_type: Type) -> Environment:
+        # setup environment
+
+        self.environment = Environment(module_type)
+        self.service_manager = self.environment.get(ServiceManager)
+        self.component_registry = self.environment.get(ComponentRegistry)
+
+        self.service_manager.startup(self)
+
+        # add routes
+
+        self.add_routes()
+        self.fast_api.include_router(self.router)
+
+        #for route in self.fast_api.routes:
+        #    print(f"{route.name}: {route.path} [{route.methods}]")
+
+        # start server thread
+
+        self.start()
+
+        # shutdown
+
+        def cleanup():
+            self.service_manager.shutdown()
+
+        atexit.register(cleanup)
+
+        # done
+
+        return self.environment