aspyx-service 0.10.4__py3-none-any.whl → 0.10.5__py3-none-any.whl

aspyx_service/__init__.py

@@ -7,12 +7,11 @@ from aspyx.di import module
 from .service import AuthorizationException, MissingTokenException, RemoteServiceException, ServiceCommunicationException, TokenException, TokenExpiredException, InvalidTokenException, component_services, ServiceException, Server, Channel, ComponentDescriptor, inject_service, ChannelAddress, ChannelInstances, ServiceManager, Component, Service, AbstractComponent, ComponentStatus, ComponentRegistry, implementation, health, component, service
 from .channels import HTTPXChannel, DispatchJSONChannel, TokenContext
 from .registries import ConsulComponentRegistry
-from .server import FastAPIServer, RequestContext
+from .server import FastAPIServer, RequestContext, ResponseContext, TokenContextMiddleware
 from .healthcheck import health_checks, health_check, HealthCheckManager, HealthStatus
 from .restchannel import RestChannel, post, get, put, delete, QueryParam, Body, rest
-from .session import Session, SessionManager
-from .authorization import AuthorizationManager, AbstractAuthorizationFactory, AuthorizationException
-
+from .session import Session, SessionManager, SessionContext
+from .authorization import AuthorizationManager, AbstractAuthorizationFactory
 
 @module()
 class ServiceModule:
@@ -53,12 +52,12 @@ __all__ = [
 
     "AuthorizationManager",
     "AbstractAuthorizationFactory",
-    "AuthorizationException",
 
     # session
 
     "Session",
     "SessionManager",
+    "SessionContext",
 
     # healthcheck
 
@@ -91,10 +90,12 @@ __all__ = [
     # registries
 
     "ConsulComponentRegistry",
-    "RequestContext",
 
     # server
 
     "FastAPIServer",
-    "RequestContext"
+    "RequestContext",
+    "ResponseContext",
+    "TokenContext",
+    "TokenContextMiddleware",
 ]

aspyx_service/authorization.py

@@ -9,13 +9,6 @@ from aspyx.di import injectable, inject, order
 from aspyx.di.aop import Invocation
 from aspyx.reflection import TypeDescriptor, Decorators
 
-
-class AuthorizationException(Exception):
-    """
-    Any authorization exception
-    """
-    pass
-
 def get_method_class(method):
     if inspect.ismethod(method) or inspect.isfunction(method):
         qualname = method.__qualname__
@@ -38,11 +31,10 @@ class AuthorizationManager:
         """
         Base class for authorization checks
         """
-        def check(self, invocation: Invocation):
+        def authorize(self, invocation: Invocation):
             """
-            execute the authorization check. Throws an exception in case of violations,
+            execute the authorization check. Throws an exception in case of violations
             """
-            pass
 
     class AuthorizationFactory(ABC):
         """
@@ -62,7 +54,6 @@ class AuthorizationManager:
             Returns:
                 an authorization check or None
             """
-            pass
 
     # constructor
 
@@ -111,9 +102,9 @@ class AuthorizationManager:
 
         return checks
 
-    def check(self, invocation: Invocation) -> Optional[Authorization]:
+    def authorize(self, invocation: Invocation):
         for check in self.get_checks(invocation.func):
-            check.check(invocation)
+            check.authorize(invocation)
 
 class AbstractAuthorizationFactory(AuthorizationManager.AuthorizationFactory):
     """

aspyx_service/channels.py

@@ -16,11 +16,11 @@ from pydantic import BaseModel
 from aspyx.di.configuration import inject_value
 from aspyx.reflection import DynamicProxy, TypeDescriptor
 from aspyx.threading import ThreadLocal, ContextLocal
+from aspyx.util import get_deserializer, TypeDeserializer, TypeSerializer, get_serializer
 from .service import ServiceManager, ServiceCommunicationException, TokenExpiredException, InvalidTokenException, \
     AuthorizationException, MissingTokenException
 
 from .service import ComponentDescriptor, ChannelInstances, ServiceException, channel, Channel, RemoteServiceException
-from .serialization import get_deserializer, TypeDeserializer, TypeSerializer, get_serializer
 
 class TokenContext:
     """
@@ -208,10 +208,11 @@ class HTTPXChannel(Channel):
                 if "invalid_token" in www_auth:
                     if 'expired' in www_auth:
                         raise TokenExpiredException() from e
-                    elif 'missing' in www_auth:
+
+                    if 'missing' in www_auth:
                         raise MissingTokenException() from e
-                    else:
-                        raise InvalidTokenException() from e
+
+                    raise InvalidTokenException() from e
 
             raise AuthorizationException(str(e)) from e
         except httpx.HTTPError as e:
@@ -451,10 +452,11 @@ class DispatchMSPackChannel(HTTPXChannel):
                 if "invalid_token" in www_auth:
                     if 'expired' in www_auth:
                         raise TokenExpiredException() from e
-                    elif 'missing' in www_auth:
+
+                    if 'missing' in www_auth:
                         raise MissingTokenException() from e
-                    else:
-                        raise InvalidTokenException() from e
+
+                    raise InvalidTokenException() from e
 
             raise RemoteServiceException(str(e)) from e
 

aspyx_service/restchannel.py

@@ -6,19 +6,15 @@ import re
 from dataclasses import is_dataclass
 
 from typing import get_type_hints, TypeVar, Annotated, Callable, get_origin, get_args, Type
-
-
 from pydantic import BaseModel
 
-from .channels import HTTPXChannel
-
 from aspyx.reflection import DynamicProxy, Decorators
+
+from .channels import HTTPXChannel
 from .service import channel, ServiceCommunicationException
 
 T = TypeVar("T")
 
-
-
 class BodyMarker:
     pass
 

aspyx_service/server.py

@@ -1,33 +1,61 @@
 """
 FastAPI server implementation for the aspyx service framework.
 """
+from __future__ import annotations
 import atexit
+import functools
 import inspect
 import threading
 from typing import Type, Optional, Callable, Any
-
-from fastapi.responses import JSONResponse
+import contextvars
 import msgpack
 import uvicorn
 
 from fastapi import FastAPI, APIRouter, Request as HttpRequest, Response as HttpResponse, HTTPException
-import contextvars
 
+
+from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 
-from aspyx.di import Environment, injectable, on_init, inject_environment
+from aspyx.di import Environment, injectable, on_init, inject_environment, on_destroy
 from aspyx.reflection import TypeDescriptor, Decorators
+from aspyx.util import get_deserializer, get_serializer
 
 from .service import ComponentRegistry
 from .healthcheck import HealthCheckManager
 
-from .serialization import get_deserializer
-
 from .service import Server, ServiceManager
 from .channels import Request, Response, TokenContext
 
 from .restchannel import get, post, put, delete, rest
 
+class ResponseContext:
+    response_var = contextvars.ContextVar[Optional['ResponseContext.Response']]("response", default=None)
+
+    class Response:
+        def __init__(self):
+            self.cookies = {}
+
+        def set_cookie(self, key, value):
+            self.cookies[key] = value
+
+    @classmethod
+    def get(cls) -> ResponseContext.Response:
+        response = ResponseContext.Response()
+
+        cls.response_var.set(response)
+
+        return response
+
+    @classmethod
+    def is_set(cls) -> Optional[ResponseContext.Response]:
+        return cls.response_var.get()
+
+    @classmethod
+    def reset(cls) -> None:
+        cls.response_var.set(None)
+
+
 class RequestContext:
     """
     A request context is used to remember the current http request in the current thread
@@ -61,7 +89,7 @@ class RequestContext:
         finally:
             self.request_var.reset(token)
 
-class TokenMiddleware(BaseHTTPMiddleware):
+class TokenContextMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next):
         access_token = request.cookies.get("access_token") or request.headers.get("Authorization")
         #refresh_token = request.cookies.get("refresh_token")
@@ -74,26 +102,15 @@ class TokenMiddleware(BaseHTTPMiddleware):
         finally:
             TokenContext.clear()
 
-def create_server() -> FastAPI:
-    server = FastAPI()
-
-    server.add_middleware(RequestContext)
-    server.add_middleware(TokenMiddleware)
-
-    return server
-
-@injectable()
 class FastAPIServer(Server):
     """
     A server utilizing fastapi framework.
     """
 
-    fast_api = create_server()
-
     # class methods
 
     @classmethod
-    def boot(cls, module: Type, host="0.0.0.0", port=8000, start = True) -> 'FastAPIServer':
+    def boot(cls, module: Type, host="0.0.0.0", port=8000, start_thread = True) -> Environment:
         """
         boot the DI infrastructure of the supplied module and optionally start a fastapi thread given the url
         Args:
@@ -102,22 +119,23 @@ class FastAPIServer(Server):
             port: the port
 
         Returns:
-            thr created server
+            the created environment
         """
+
         cls.port = port
 
         environment = Environment(module)
 
         server = environment.get(FastAPIServer)
 
-        if start:
-            server.start_fastapi(host)
+        if start_thread:
+            server.start_server(host)
 
-        return server
+        return environment
 
     # constructor
 
-    def __init__(self, service_manager: ServiceManager, component_registry: ComponentRegistry):
+    def __init__(self, fast_api: FastAPI, service_manager: ServiceManager, component_registry: ComponentRegistry):
         super().__init__()
 
         self.environment : Optional[Environment] = None
@@ -125,10 +143,14 @@ class FastAPIServer(Server):
         self.component_registry = component_registry
 
         self.host = "localhost"
+        self.fast_api = fast_api
         self.server_thread = None
 
         self.router = APIRouter()
 
+        self.server : Optional[uvicorn.Server] = None
+        self.thread : Optional[threading.Thread] = None
+
         # cache
 
         self.deserializers: dict[str, list[Callable]] = {}
@@ -143,6 +165,8 @@ class FastAPIServer(Server):
     def set_environment(self, environment: Environment):
         self.environment = environment
 
+    # lifecycle
+
     @on_init()
     def on_init(self):
         self.service_manager.startup(self)
@@ -162,12 +186,52 @@ class FastAPIServer(Server):
 
         atexit.register(cleanup)
 
+    @on_destroy()
+    def on_destroy(self):
+        if self.server is not None:
+            self.server.should_exit = True
+            self.thread.join()
+
     # private
 
     def add_routes(self):
         """
         add everything that looks like an http endpoint
         """
+
+        def wrap_service_method(handler, return_type):
+            sig = inspect.signature(handler)
+
+            @functools.wraps(handler)
+            async def wrapper(*args, **kwargs):
+                try:
+                    result = handler(*args, **kwargs)
+                    if inspect.iscoroutine(result):
+                        result = await result
+
+                except HTTPException as e:
+                    raise
+                except Exception as e:
+                    result = {"error": str(e)}
+
+                json_response = JSONResponse(get_serializer(return_type)(result))
+
+                local_response = ResponseContext.is_set()
+                if local_response is not None:
+                    for key, value in  local_response.cookies.items():
+                        json_response.set_cookie(key, value)
+
+                    ResponseContext.reset()
+
+                return json_response
+
+            # Optionally attach response_model info for docs
+
+            wrapper.__signature__ = sig
+            wrapper.__annotations__ = {"return": return_type}
+
+            return wrapper
+
         for descriptor in self.service_manager.descriptors.values():
             if not descriptor.is_component() and descriptor.is_local():
                 prefix = ""
@@ -183,25 +247,23 @@ class FastAPIServer(Server):
                     if decorator is not None:
                         self.router.add_api_route(
                             path=prefix + decorator.args[0],
-                            endpoint=getattr(instance, method.get_name()),
+                            endpoint=wrap_service_method(getattr(instance, method.get_name()), method.return_type),
                             methods=[decorator.decorator.__name__],
                             name=f"{descriptor.get_component_descriptor().name}.{descriptor.name}.{method.get_name()}",
                             response_model=method.return_type,
                         )
 
-    def start_fastapi(self, host: str):
+    def start_server(self, host: str):
         """
         start the fastapi server in a thread
         """
         self.host = host
 
-        config = uvicorn.Config(self.fast_api, host=self.host, port=self.port, access_log=False)
-        server = uvicorn.Server(config)
-
-        thread = threading.Thread(target=server.run, daemon=True)
-        thread.start()
+        config = uvicorn.Config(self.fast_api, host=host, port=self.port, access_log=False)
 
-        return thread
+        self.server = uvicorn.Server(config)
+        self.thread = threading.Thread(target=self.server.run, daemon=True)
+        self.thread.start()
 
     def get_deserializers(self, service: Type, method):
         deserializers = self.deserializers.get(method, None)

aspyx_service/session.py

@@ -1,13 +1,13 @@
 """
 session related module
 """
+from abc import ABC, abstractmethod
 import contextvars
 from typing import Type, Optional, Callable, Any, TypeVar
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 from cachetools import TTLCache
 
 from aspyx.di import injectable
-from aspyx.threading import ThreadLocal
 
 
 class Session:
@@ -19,18 +19,16 @@ class Session:
 
 T = TypeVar("T")
 
-@injectable()
-class SessionManager:
-    """
-    A SessionManager controls the lifecycle of sessions and is responsible to establish a session thread local.
-    """
-    #current_session = ThreadLocal[Session]()
-    current_session  = contextvars.ContextVar("session")
+class SessionContext:
+    # class properties
+
+    # current_session = ThreadLocal[Session]()
+    current_session = contextvars.ContextVar("session")
 
     @classmethod
-    def current(cls, type: Type[T]) -> T:
+    def get(cls, type: Type[T]) -> T:
         """
-        return the current session associated with the thread
+        return the current session associated with the context
         Args:
             type:  the session type
 
@@ -40,40 +38,85 @@ class SessionManager:
         return cls.current_session.get()
 
     @classmethod
-    def set_session(cls, session: Session) -> None:
+    def set(cls, session: Session) -> None:
         """
-        set the current session in the thread context
+        set the current session in the context
         Args:
             session: the session
         """
         cls.current_session.set(session)
 
     @classmethod
-    def delete_session(cls) -> None:
+    def clear(cls) -> None:
         """
         delete the current session
         """
-        cls.current_session.set(None)#clear()
+        cls.current_session.set(None)  # clear()
+
+@injectable()
+class SessionManager(SessionContext):
+    """
+    A SessionManager controls the lifecycle of sessions and is responsible to establish a session context local.
+    """
+
+    # local classes
+
+    class Storage(ABC):
+        @abstractmethod
+        def store(self, token: str, session: Session, ttl_seconds: int):
+            pass
+
+        @abstractmethod
+        def read(self, token: str) -> Optional[Session]:
+            pass
+
+    class InMemoryStorage(Storage):
+        """
+        InMemoryStorage is a simple in-memory storage for sessions.
+        It uses a TTLCache to store sessions with a time-to-live.
+        """
+        # constructor
+
+        def __init__(self, max_size = 1000, ttl = 3600):
+            self.cache = TTLCache(maxsize=max_size, ttl=ttl)
+
+        # implement
+
+        def store(self, token: str, session: 'Session', ttl_seconds: int):
+            expiry_time = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)
+            self.cache[token] = (session, expiry_time)
+
+        def read(self, token: str) -> Optional['Session']:
+            value = self.cache.get(token)
+            if value is None:
+                return None
+
+            session, expiry = value
+            if expiry < datetime.now(timezone.utc):
+                del self.cache[token]
+                return None
+
+            return session
 
     # constructor
 
-    def __init__(self):
-        self.sessions = TTLCache(maxsize=1000, ttl=3600)
-        self.session_creator : Optional[Callable[[Any], Session]] = None
+    def __init__(self, storage: 'SessionManager.Storage'):
+        self.storage = storage
+        self.session_factory : Optional[Callable[[Any], Session]] = None
 
     # public
 
-    def set_session_factory(self, callable: Callable[..., Session]) -> None:
+    def set_factory(self, factory: Callable[..., Session]) -> None:
         """
         set a factory function that will be used to create a concrete session
         Args:
-            callable: the function
+            factory: the function
         """
-        self.session_creator = callable
+        self.session_factory = factory
 
     def create_session(self, *args, **kwargs) -> Session:
         """
-        create a session given the argument s(usually a token, etc.)
+        create a session given the arguments (usually a token, etc.)
         Args:
             args: rest args
             kwargs: keyword args
@@ -81,17 +124,13 @@ class SessionManager:
         Returns:
             the new session
         """
-        return self.session_creator(*args, **kwargs)
+        return self.session_factory(*args, **kwargs)
 
     def store_session(self, token: str, session: Session, expiry: datetime):
         now = datetime.now(timezone.utc)
         ttl_seconds = max(int((expiry - now).total_seconds()), 0)
-        self.sessions[token] = (session, ttl_seconds)
 
-    def get_session(self, token: str) -> Optional[Session]:
-        value = self.sessions.get(token)
-        if value is None:
-            return None
+        self.storage.store(token, session, ttl_seconds)
 
-        session, ttl = value
-        return session
+    def read_session(self, token: str) -> Optional[Session]:
+        return self.storage.read(token)

{aspyx_service-0.10.4.dist-info → aspyx_service-0.10.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.4
+Version: 0.10.5
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -26,8 +26,7 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.5.3
-Requires-Dist: cachetools~=5.5.2
+Requires-Dist: aspyx>=1.6.0
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
@@ -110,18 +109,20 @@ class TestComponent(Component):
 After booting the DI infrastructure with a main module we could already call a service:
 
 **Example**:
+
 ```python
 @module(imports=[ServiceModule])
 class Module:
     def __init__(self):
         pass
-    
+
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
-        return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=8500)) # a consul based registry!
+        return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=8500))  # a consul based registry!
+
 
 environment = Environment(Module)
-service_manager = environment.get(ServiceManager)
+service_manager = environment.read(ServiceManager)
 
 service = service_manager.get_service(TestService)
 
@@ -202,6 +203,14 @@ The library offers:
 As well as the DI and AOP core, all mechanisms are heavily optimized.
 A simple benchmark resulted in message roundtrips in significanlty under a ms per call.
 
+## Installation
+
+Just install from PyPI with 
+
+`pip install aspyx-service`
+
+The library is tested with all Python version >= 3.9
+
 Let's see some details
 
 ## Service and Component declaration 
@@ -484,18 +493,26 @@ class ChannelAdvice:
 
 ## FastAPI server
 
-In order to expose components via HTTP, the corresponding infrastructure in form of a FastAPI server needs to be setup. 
+The required - `FastAPI` - infrastructure to expose those services requires:
 
+- a `FastAPI` instance
+- an injectable `FastAPIServer`
+- and a final `boot` call with the root module, which will return an `Environment`
 
 ```python
-@module()
-class Module():
+fast_api = FastAPI() # so you can run it with uvivorn from command-line
+
+@module(imports=[ServiceModule])
+class Module:
     def __init__(self):
         pass
+
+    @create()
+    def create_server(self,  service_manager: ServiceManager, component_registry: ComponentRegistry) -> FastAPIServer:
+        return FastAPIServer(fastapi, service_manager, component_registry)
     
- server = FastAPIServer(host="0.0.0.0", port=8000)
 
- environment = server.boot(Module) # will start the http server
+environment = FastAPIServer.boot(Moudle, host="0.0.0.0", port=8000)
 ```
 
 This setup will also expose all service interfaces decorated with the corresponding http decorators!

aspyx_service-0.10.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+aspyx_service/__init__.py,sha256=OWJoScdDVK1NTs9cIgImShgEdJb8TZHLBQjS11rA0Yo,2564
+aspyx_service/authorization.py,sha256=0B1xb0WrRaj2rcGTHVUhh6i8aA0sy7BmpYA18xI9LQA,3833
+aspyx_service/channels.py,sha256=u1afqUfcmVgLxXDXC2BYHH-dMozLcmVROuPRpypSwr8,16397
+aspyx_service/healthcheck.py,sha256=vjfY7s5kd5mRJynVpvAJ4BvVF7QY1xrvj94Y-m041LQ,5615
+aspyx_service/registries.py,sha256=bnTjKb40fbZXA52E2lDSEzCWI5_NBKZzQjc8ffufB5g,8039
+aspyx_service/restchannel.py,sha256=0Xb8grEE8Dyx3g3ENl78DDMKa2WGjIKIPgOrpw5p9ak,8470
+aspyx_service/server.py,sha256=HLMsEpiXgpF7s1r1_1iRiufAvDfrOZGvljPjpf-7RCM,11096
+aspyx_service/service.py,sha256=drETAZasbYJZisnmbhAqW0-mHghJ3IWyPaU-7etxvBI,27003
+aspyx_service/session.py,sha256=HjGpnmwdislc8Ur6pQbSMi2K-lvTsb9_XyO80zupiF8,3713
+aspyx_service-0.10.5.dist-info/METADATA,sha256=QHq4kp7Zn9roaenqpDa_t9KqZBlr0Ku4F7621L1ZM5k,17946
+aspyx_service-0.10.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aspyx_service-0.10.5.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx_service-0.10.5.dist-info/RECORD,,

aspyx_service/serialization.py

@@ -1,137 +0,0 @@
-"""
-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
-
-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 typ.model_validate
-
-        if is_dataclass(typ):
-            field_deserializers = {f.name: TypeDeserializer(f.type) for f in fields(typ)}
-            def deser_dataclass(value):
-                if is_dataclass(value):
-                    return 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
-
-class TypeSerializer:
-    def __init__(self, typ):
-        self.typ = typ
-        self.serializer = self._build_serializer(typ)
-
-    def __call__(self, value):
-        return self.serializer(value)
-
-    def _build_serializer(self, typ):
-        origin = get_origin(typ)
-        args = get_args(typ)
-
-        if origin is Union:
-            serializers = [TypeSerializer(arg) for arg in args if arg is not type(None)]
-            def ser_union(value):
-                if value is None:
-                    return None
-                for s in serializers:
-                    try:
-                        return s(value)
-                    except Exception:
-                        continue
-                return value
-            return ser_union
-
-        if isinstance(typ, type) and issubclass(typ, BaseModel):
-            return lambda v: v.model_dump() if v is not None else None
-
-        if is_dataclass(typ):
-            field_serializers = {f.name: TypeSerializer(f.type) for f in fields(typ)}
-            def ser_dataclass(obj):
-                if obj is None:
-                    return None
-                return {k: field_serializers[k](getattr(obj, k)) for k in field_serializers}
-            return ser_dataclass
-
-        if origin is list:
-            item_ser = TypeSerializer(args[0]) if args else lambda x: x
-            return lambda v: [item_ser(item) for item in v] if v is not None else None
-
-        if origin is dict:
-            key_ser = TypeSerializer(args[0]) if args else lambda x: x
-            val_ser = TypeSerializer(args[1]) if len(args) > 1 else lambda x: x
-            return lambda v: {key_ser(k): val_ser(val) for k, val in v.items()} if v is not None else None
-
-        # Fallback: primitive Typen oder unbekannt
-        return lambda v: v
-
-@lru_cache(maxsize=512)
-def get_deserializer(typ):
-    """
-    return a function that is able to deserialize a value of the specified type
-
-    Args:
-        typ: the type
-
-    Returns:
-
-    """
-    return TypeDeserializer(typ)
-
-@lru_cache(maxsize=512)
-def get_serializer(typ):
-    """
-    return a function that is able to deserialize a value of the specified type
-
-    Args:
-        typ: the type
-
-    Returns:
-
-    """
-    return TypeSerializer(typ)

aspyx_service-0.10.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-aspyx_service/__init__.py,sha256=h9zcGzYaVdU2_mXON-k-mgYErEJ7eIs-wjNDKtet1_s,2488
-aspyx_service/authorization.py,sha256=vBM8uPsAZwMiTilqFZMJ101Qy37gL2Y9vdGTLp-ykFg,3983
-aspyx_service/channels.py,sha256=3Fv6055n1hw8HQ6MKu2BROsq6gmPdKIhayUhQiTRLic,16461
-aspyx_service/healthcheck.py,sha256=vjfY7s5kd5mRJynVpvAJ4BvVF7QY1xrvj94Y-m041LQ,5615
-aspyx_service/registries.py,sha256=bnTjKb40fbZXA52E2lDSEzCWI5_NBKZzQjc8ffufB5g,8039
-aspyx_service/restchannel.py,sha256=wutLGnxqMAS1oX7cc1pvN8qIIpjeBEvPz_hsKeWHVZs,8474
-aspyx_service/serialization.py,sha256=OrwOAUsHQyGDyhYTkTc-0v8urYMbh0_3fgkpTvNOl0o,4214
-aspyx_service/server.py,sha256=_LFRy1XIXTbu7CLoXsoPGQwKHkpSPDh82VV4ppahzr0,9057
-aspyx_service/service.py,sha256=drETAZasbYJZisnmbhAqW0-mHghJ3IWyPaU-7etxvBI,27003
-aspyx_service/session.py,sha256=ytWRTlnu1kDpTkLBCy_WF2i-mdffG-exIqsUQZ1Udo0,2592
-aspyx_service-0.10.4.dist-info/METADATA,sha256=-WA5_ta5gP3AXy8EA0JhFzoFstaS_RgeGjyglOAYqXw,17499
-aspyx_service-0.10.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aspyx_service-0.10.4.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx_service-0.10.4.dist-info/RECORD,,