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

aspyx_service/session.py

@@ -0,0 +1,136 @@
+"""
+session related module
+"""
+from abc import ABC, abstractmethod
+import contextvars
+from typing import Type, Optional, Callable, Any, TypeVar
+from datetime import datetime, timezone, timedelta
+from cachetools import TTLCache
+
+from aspyx.di import injectable
+
+
+class Session:
+    """
+    Base class for objects covers data related to a server side session.
+    """
+    def __init__(self):
+        pass
+
+T = TypeVar("T")
+
+class SessionContext:
+    # class properties
+
+    # current_session = ThreadLocal[Session]()
+    current_session = contextvars.ContextVar("session")
+
+    @classmethod
+    def get(cls, type: Type[T]) -> T:
+        """
+        return the current session associated with the context
+        Args:
+            type:  the session type
+
+        Returns:
+            the current session
+        """
+        return cls.current_session.get()
+
+    @classmethod
+    def set(cls, session: Session) -> None:
+        """
+        set the current session in the context
+        Args:
+            session: the session
+        """
+        cls.current_session.set(session)
+
+    @classmethod
+    def clear(cls) -> None:
+        """
+        delete the current session
+        """
+        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, storage: 'SessionManager.Storage'):
+        self.storage = storage
+        self.session_factory : Optional[Callable[[Any], Session]] = None
+
+    # public
+
+    def set_factory(self, factory: Callable[..., Session]) -> None:
+        """
+        set a factory function that will be used to create a concrete session
+        Args:
+            factory: the function
+        """
+        self.session_factory = factory
+
+    def create_session(self, *args, **kwargs) -> Session:
+        """
+        create a session given the arguments (usually a token, etc.)
+        Args:
+            args: rest args
+            kwargs: keyword args
+
+        Returns:
+            the new session
+        """
+        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.storage.store(token, session, ttl_seconds)
+
+    def read_session(self, token: str) -> Optional[Session]:
+        return self.storage.read(token)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.3
+Version: 0.10.5
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.5.1
+Requires-Dist: aspyx>=1.6.0
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
@@ -60,6 +60,8 @@ Description-Content-Type: text/markdown
   - [Rest Calls](#rest-calls)
   - [Intercepting calls](#intercepting-calls)
 - [FastAPI server](#fastapi-server)
+- [Session](#session)
+- [Authorization](#authorization)
 - [Implementing Channels](#implementing-channels)
 - [Version History](#version-history)
 
@@ -107,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)
 
@@ -166,10 +170,24 @@ environment = server.boot(Module)
 Of course, service can also be called locally. In case of multiple possible channels, a keyword argument is used to 
 determine a specific channel. As a local channel has the name "local", the appropriate call is:
 
+**Example**:
+
 ```python
  service = service_manager.get_service(TestService, preferred_channel="local")
 ```
 
+The default can be set globally with the method `set_preferred_channel(channel: str)`
+
+Injecting services is also possible via the decorator `@inject_service(preferred_channel=""")`
+
+**Example**:
+
+```python
+@inject_service()
+def set_service(self, service: TestService)
+   self.service = service
+```
+
 ## Features
 
 The library offers:
@@ -185,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 
@@ -352,12 +378,14 @@ Channels implement the possible transport layer protocols. In the sense of a dyn
 Several channels are implemented:
 
 - `dispatch-json`
-   channel that dispatches generic `Request` objects via a `invoke` POST-call
+   channel that posts generic `Request` objects via a `invoke` POST-call
 - `dispatch-msgpack`
-   channel that dispatches generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
+   channel that posts generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
 - `rest`
   channel that executes regular rest-calls as defined by a couple of decorators.
 
+The `dispatch`channels have the big advantage, that you don`t have to deal with additional http decorators!
+
 All channels react on changed URLs as provided by the component registry.
 
 A so called `URLSelector` is used internally to provide URLs for every single call. Two subclasses exist that offer a different logic
@@ -465,23 +493,39 @@ 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!
 No need to add any FastAPI decorators, since the mapping is already done internally! 
 
+## Session
+
+TODO
+
+## Authorization
+
+TODO
+
 ## Implementing Channels
 
 To implement a new channel, you only need to derive from one of the possible base classes ( `Channel` or `HTTPXChannel` that already has a `httpx` client)

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.parse_obj
-
-        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.dict() 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.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-aspyx_service/__init__.py,sha256=6t24VPrSCG83EAvYlqCKdEcEbyCY3vrSb5GoAx01Ymg,1662
-aspyx_service/channels.py,sha256=p5JIyo7eWyBiR2xQrfsEvq2L89FzeFT1tqKYhvXQbXs,9035
-aspyx_service/healthcheck.py,sha256=8ZPSkAx6ypoYaxDMkJT_MtL2pEN2LcUAishAWPCy-3I,5624
-aspyx_service/registries.py,sha256=JSsD32F8VffZMHyEDuapEWtvmem5SK9kR6bgsFRLFZQ,8002
-aspyx_service/restchannel.py,sha256=Q_7RURjZZW7N2LBLY9BL7qKyS_A62X7yFoGUoE-_0YY,9103
-aspyx_service/serialization.py,sha256=GEgfg1cNSOJ_oe0gEm0ajzugLyUmPiEsp9Qz6Fu4vkA,4207
-aspyx_service/server.py,sha256=PHKx3O90jnxm8dA4z331_51znhU-HlRB2Fa1AikmFXA,7052
-aspyx_service/service.py,sha256=Odl6_nvOOJ2lFjqCLJD8KLPt-sCG55VtQQiKTyNEOPs,26062
-aspyx_service-0.10.3.dist-info/METADATA,sha256=MrWNfy3T2m4G5MyKlV4Spr2yi6N_hE1VLRT3vNJ6Hm0,16955
-aspyx_service-0.10.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aspyx_service-0.10.3.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx_service-0.10.3.dist-info/RECORD,,