aspyx-service 0.10.1__tar.gz → 0.10.2__tar.gz

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.1
+Version: 0.10.2
 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.0
+Requires-Dist: aspyx>=1.5.1
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
@@ -34,6 +34,18 @@ Requires-Dist: python-consul2~=0.1.5
 Requires-Dist: uvicorn[standard]
 Description-Content-Type: text/markdown
 
+# aspyx
+
+![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
+![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
+![Python Versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)
+![License](https://img.shields.io/github/license/coolsamson7/aspyx)
+![coverage](https://img.shields.io/badge/coverage-94%25-brightgreen)
+[![PyPI](https://img.shields.io/pypi/v/aspyx)](https://pypi.org/project/aspyx/)
+[![Docs](https://img.shields.io/badge/docs-online-blue?logo=github)](https://coolsamson7.github.io/aspyx/index/introduction)
+
+![image](https://github.com/user-attachments/assets/e808210a-b1a4-4fd0-93f1-b5f9845fa520)
+
 # Service
 
 - [Introduction](#introduction)

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/README.md

@@ -1,3 +1,15 @@
+# aspyx
+
+![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
+![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
+![Python Versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)
+![License](https://img.shields.io/github/license/coolsamson7/aspyx)
+![coverage](https://img.shields.io/badge/coverage-94%25-brightgreen)
+[![PyPI](https://img.shields.io/pypi/v/aspyx)](https://pypi.org/project/aspyx/)
+[![Docs](https://img.shields.io/badge/docs-online-blue?logo=github)](https://coolsamson7.github.io/aspyx/index/introduction)
+
+![image](https://github.com/user-attachments/assets/e808210a-b1a4-4fd0-93f1-b5f9845fa520)
+
 # Service
 
 - [Introduction](#introduction)

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/pyproject.toml

@@ -2,14 +2,14 @@
 
 [project]
 name = "aspyx_service"
-version = "0.10.1"
+version = "0.10.2"
 description = "Aspyx Service framework"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.9"
 dependencies = [
-    "aspyx>=1.5.0",
+    "aspyx>=1.5.1",
     "python-consul2~=0.1.5",
     "fastapi~=0.115.13",
     "httpx~=0.28.1",

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/src/aspyx_service/channels.py

@@ -11,8 +11,9 @@ import msgpack
 from httpx import Client, AsyncClient
 from pydantic import BaseModel
 
+from aspyx.di.configuration import inject_value
 from aspyx.reflection import DynamicProxy, TypeDescriptor
-from .service import ServiceManager
+from .service import ServiceManager, ServiceCommunicationException
 
 from .service import ComponentDescriptor, ChannelInstances, ServiceException, channel, Channel, RemoteServiceException
 from .serialization import get_deserializer
@@ -23,7 +24,8 @@ class HTTPXChannel(Channel):
         "client",
         "async_client",
         "service_names",
-        "deserializers"
+        "deserializers",
+        "timeout"
     ]
 
     # class methods
@@ -58,11 +60,18 @@ class HTTPXChannel(Channel):
     def __init__(self):
         super().__init__()
 
+        self.timeout = 1000.0
         self.client: Optional[Client] = None
         self.async_client: Optional[AsyncClient] = None
         self.service_names: dict[Type, str] = {}
         self.deserializers: dict[Callable, Callable] = {}
 
+    # inject
+
+    @inject_value("http.timeout", default=1000.0)
+    def set_timeout(self, timeout: float) -> None:
+        self.timeout = timeout
+
     # protected
 
     def get_deserializer(self, type: Type, method: Callable) -> Type:
@@ -99,16 +108,16 @@ class HTTPXChannel(Channel):
 
         return self.client
 
-    def get_async_client(self) -> Client:
+    def get_async_client(self) -> AsyncClient:
         if self.async_client is None:
             self.async_client = self.make_async_client()
 
         return self.async_client
 
-    def make_client(self):
+    def make_client(self) -> Client:
         return Client()  # base_url=url
 
-    def make_async_client(self):
+    def make_async_client(self) -> AsyncClient:
         return AsyncClient()  # base_url=url
 
 class Request(BaseModel):
@@ -122,7 +131,7 @@ class Response(BaseModel):
 @channel("dispatch-json")
 class DispatchJSONChannel(HTTPXChannel):
     """
-    A channel that calls a POST on th endpoint `ìnvoke` sending a request body containing information on the
+    A channel that calls a POST on the endpoint `ìnvoke` sending a request body containing information on the
     called component, service and method and the arguments.
     """
     # constructor
@@ -144,40 +153,49 @@ class DispatchJSONChannel(HTTPXChannel):
 
     def invoke(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
-        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}", args=invocation.args)
+        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+                          args=invocation.args)
 
         dict = self.to_dict(request)
         try:
-            if self.client is not None:
-                result = Response(**self.get_client().post(f"{self.get_url()}/invoke", json=dict, timeout=30000.0).json())
-                if result.exception is not None:
-                    raise RemoteServiceException(f"server side exception {result.exception}")
-
-                return self.get_deserializer(invocation.type, invocation.method)(result.result)
-            else:
-                raise ServiceException(f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+            result = Response(**self.get_client().post(f"{self.get_url()}/invoke", json=dict, timeout=self.timeout).json())
+            if result.exception is not None:
+                raise RemoteServiceException(f"server side exception {result.exception}")
+
+            return self.get_deserializer(invocation.type, invocation.method)(result.result)
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
-            raise ServiceException(f"communication exception {e}") from e
+            raise ServiceCommunicationException(f"communication exception {e}") from e
+
 
     async def invoke_async(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
         request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
                           args=invocation.args)
-
         dict = self.to_dict(request)
         try:
-            if self.async_client is not None:
-                data =  await self.async_client.post(f"{self.get_url()}/invoke", json=dict, timeout=30000.0)
-                result = Response(**data.json())
-                if result.exception is not None:
-                    raise RemoteServiceException(f"server side exception {result.exception}")
-
-                return self.get_deserializer(invocation.type, invocation.method)(result.result)
-            else:
-                raise ServiceException(
-                    f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+            data =  await self.get_async_client().post(f"{self.get_url()}/invoke", json=dict, timeout=self.timeout)
+            result = Response(**data.json())
+
+            if result.exception is not None:
+                raise RemoteServiceException(f"server side exception {result.exception}")
+
+            return self.get_deserializer(invocation.type, invocation.method)(result.result)
+
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
-            raise ServiceException(f"communication exception {e}") from e
+            raise ServiceCommunicationException(f"communication exception {e}") from e
+
 
 @channel("dispatch-msgpack")
 class DispatchMSPackChannel(HTTPXChannel):
@@ -208,7 +226,7 @@ class DispatchMSPackChannel(HTTPXChannel):
                 f"{self.get_url()}/invoke",
                 content=packed,
                 headers={"Content-Type": "application/msgpack"},
-                timeout=30.0
+                timeout=self.timeout
             )
 
             result = msgpack.unpackb(response.content, raw=False)
@@ -218,6 +236,12 @@ class DispatchMSPackChannel(HTTPXChannel):
 
             return self.get_deserializer(invocation.type, invocation.method)(result["result"])
 
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
             raise ServiceException(f"msgpack exception: {e}") from e
 
@@ -233,7 +257,7 @@ class DispatchMSPackChannel(HTTPXChannel):
                 f"{self.get_url()}/invoke",
                 content=packed,
                 headers={"Content-Type": "application/msgpack"},
-                timeout=30.0
+                timeout=self.timeout
             )
 
             result = msgpack.unpackb(response.content, raw=False)
@@ -243,5 +267,11 @@ class DispatchMSPackChannel(HTTPXChannel):
 
             return self.get_deserializer(invocation.type, invocation.method)(result["result"])
 
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
             raise ServiceException(f"msgpack exception: {e}") from e

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/src/aspyx_service/registries.py

@@ -6,7 +6,6 @@ import threading
 from abc import abstractmethod
 import time
 from typing import Optional
-from urllib.parse import urlparse
 
 import consul
 
@@ -36,6 +35,9 @@ class ConsulComponentRegistry(ComponentRegistry):
         self.component_addresses : dict[str, dict[str, ChannelInstances]] = {} # comp -> channel -> address
         self.watch_channels : list[Channel] = []
         self.watchdog_interval = 5
+        self.healthcheck_interval = "10s"
+        self.healthcheck_timeout= "5s"
+        self.healthcheck_deregister = "5m"
 
     # injections
 
@@ -43,6 +45,18 @@ class ConsulComponentRegistry(ComponentRegistry):
     def set_interval(self, interval):
         self.watchdog_interval = interval
 
+    @inject_value("consul.healthcheck.interval", default="10s")
+    def set_interval(self, interval):
+        self.healthcheck_interval = interval
+
+    @inject_value("consul.healthcheck.timeout", default="3s")
+    def set_interval(self, interval):
+        self.healthcheck_timeout = interval
+
+    @inject_value("consul.healthcheck.deregister", default="5m")
+    def set_interval(self, interval):
+        self.healthcheck_deregister = interval
+
     # lifecycle hooks
 
     @on_init()
@@ -116,8 +130,6 @@ class ConsulComponentRegistry(ComponentRegistry):
     def watch(self, channel: Channel) -> None:
         self.watch_channels.append(channel)
 
-        #self.component_addresses[channel.component_descriptor.name] = {}
-
    # public
 
     def register_service(self, name, service_id, health: str, tags=None, meta=None) -> None:
@@ -130,9 +142,9 @@ class ConsulComponentRegistry(ComponentRegistry):
             meta=meta or {},
             check=consul.Check().http(
                 url=f"http://{self.ip}:{self.port}{health}",
-                interval="10s",
-                timeout="3s",
-                deregister="5m")
+                interval=self.healthcheck_interval,
+                timeout=self.healthcheck_timeout,
+                deregister=self.healthcheck_deregister)
             )
 
     def deregister(self, descriptor: ComponentDescriptor[Component]) -> None:
@@ -213,12 +225,13 @@ class ConsulComponentRegistry(ComponentRegistry):
 
         return list(component_addresses.values())
 
-    #200–299	passing	Service is healthy (OK, Created, No Content…)
-    #429	warning	Rate limited or degraded
-    #300–399	warning	Redirects interpreted as potential issues
-    #400–499	critical	Client errors (Bad Request, Unauthorized…)
-    #500–599	critical	Server errors (Internal Error, Timeout…)
-    #Other / No response	critical	Timeout, connection refused, etc.
+    # 200–299	passing	Service is healthy (OK, Created, No Content…)
+    # 429	warning	Rate limited or degraded
+    # 300–399	warning	Redirects interpreted as potential issues
+    # 400–499	critical	Client errors (Bad Request, Unauthorized…)
+    # 500–599	critical	Server errors (Internal Error, Timeout…)
+    # Other / No response	critical	Timeout, connection refused, etc.
+
     def map_health(self, health: HealthCheckManager.Health) -> int:
         if health.status is HealthStatus.OK:
             return 200

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/src/aspyx_service/restchannel.py

@@ -10,7 +10,7 @@ from typing import get_type_hints, TypeVar, Annotated, Callable, get_origin, get
 from pydantic import BaseModel
 
 from aspyx.reflection import DynamicProxy, Decorators
-from .service import ServiceException, channel
+from .service import channel, ServiceCommunicationException
 
 T = TypeVar("T")
 
@@ -134,6 +134,9 @@ class RestChannel(HTTPXChannel):
         def __init__(self, type: Type, method : Callable):
             self.signature = inspect.signature(method)
 
+            param_names = list(self.signature.parameters.keys())
+            param_names.remove("self")
+
             prefix = ""
             if Decorators.has_decorator(type, rest):
                 prefix = Decorators.get_decorator(type, rest).args[0]
@@ -155,6 +158,9 @@ class RestChannel(HTTPXChannel):
 
             self.path_param_names = set(re.findall(r"{(.*?)}", self.url_template))
 
+            for param_name in self.path_param_names:
+                param_names.remove(param_name)
+
             hints = get_type_hints(method, include_extras=True)
 
             self.body_param_name = None
@@ -163,10 +169,42 @@ class RestChannel(HTTPXChannel):
             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
+                        param_names.remove(param_name)
                     elif QueryParamMarker in metadata:
                         self.query_param_names.add(param_name)
+                        param_names.remove(param_name)
+
+            # check if something is missing
+
+            if len(param_names) > 0:
+                # check body params
+                if self.type in ("post", "put", "patch"):
+                    if self.body_param_name is None:
+                        candidates = [
+                            (name, hint)
+                            for name, hint in hints.items()
+                            if name not in self.path_param_names
+                        ]
+                        # find first dataclass or pydantic argument
+                        for name, hint in candidates:
+                            typ = hint
+                            if get_origin(typ) is Annotated:
+                                typ = get_args(typ)[0]
+                            if (
+                                    (isinstance(typ, type) and issubclass(typ, BaseModel))
+                                    or is_dataclass(typ)
+                            ):
+                                self.body_param_name = name
+                                param_names.remove(name)
+                                break
+
+            # the rest are query params
+
+            for param in param_names:
+                self.query_param_names.add(param)
 
             # return type
 
@@ -191,6 +229,42 @@ class RestChannel(HTTPXChannel):
 
     # override
 
+    async def invoke_async(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:
+            result = None
+            if call.type == "get":
+                result = await self.get_client().get(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+            elif call.type == "put":
+                result = await self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+            elif call.type == "delete":
+                result = await self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+            elif call.type == "post":
+                result = await self.get_client().post(self.get_url() + url, params=query_params, json=body,
+                                                timeout=self.timeout).json()
+
+            return self.get_deserializer(invocation.type, invocation.method)(result)
+        except ServiceCommunicationException:
+            raise
+
+        except Exception as e:
+            raise ServiceCommunicationException(f"communication exception {e}") from e
+
     def invoke(self, invocation: DynamicProxy.Invocation):
         call = self.get_call(invocation.type, invocation.method)
 
@@ -209,20 +283,19 @@ class RestChannel(HTTPXChannel):
         # 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")
+            result = None
+            if call.type == "get":
+                result = self.get_client().get(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+            elif call.type == "put":
+                result = self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+            elif call.type == "delete":
+                result = self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+            elif call.type == "post":
+                result = self.get_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout).json()
+
+            return self.get_deserializer(invocation.type, invocation.method)(result)
+        except ServiceCommunicationException:
+            raise
+
         except Exception as e:
-            raise ServiceException(f"communication exception {e}") from e
+            raise ServiceCommunicationException(f"communication exception {e}") from e

{aspyx_service-0.10.1 → aspyx_service-0.10.2}/src/aspyx_service/serialization.py

@@ -7,67 +7,6 @@ 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
 
@@ -119,6 +58,54 @@ class TypeDeserializer:
 
         # 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):
@@ -132,3 +119,16 @@ def get_deserializer(typ):
 
     """
     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.1 → aspyx_service-0.10.2}/src/aspyx_service/server.py

@@ -38,7 +38,6 @@ class FastAPIServer(Server):
         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
 
@@ -83,19 +82,17 @@ class FastAPIServer(Server):
                             response_model=method.return_type,
                         )
 
-    def start(self):
+    def start_fastapi_thread(self):
         """
         start the fastapi server in a thread
         """
 
-        config = uvicorn.Config(self.fast_api, host=self.host, port=self.port, log_level="debug")
+        config = uvicorn.Config(self.fast_api, host=self.host, port=self.port, access_log=False) #log_level="debug"
         server = uvicorn.Server(config)
 
         thread = threading.Thread(target=server.run, daemon=True)
         thread.start()
 
-        print(f"server started on {self.host}:{self.port}")
-
         return thread
 
 
@@ -212,12 +209,12 @@ class FastAPIServer(Server):
         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}]")
+        #for route in self.fast_api.routes:
+        #    print(f"{route.name}: {route.path} [{route.methods}]")
 
         # start server thread
 
-        self.start()
+        self.start_fastapi_thread()
 
         # shutdown