aspyx-service 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

aspyx_service/channels.py

@@ -3,14 +3,17 @@ Service management and dependency injection framework.
 """
 from __future__ import annotations
 
+import json
+from dataclasses import is_dataclass, asdict, fields
 from typing import Type, Optional, Any, Callable
 
 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
@@ -21,19 +24,54 @@ class HTTPXChannel(Channel):
         "client",
         "async_client",
         "service_names",
-        "deserializers"
+        "deserializers",
+        "timeout"
     ]
 
+    # class methods
+
+    @classmethod
+    def to_dict(cls, obj: Any) -> Any:
+        if isinstance(obj, BaseModel):
+            return obj.dict()
+
+
+        elif is_dataclass(obj):
+            return {
+                f.name: cls.to_dict(getattr(obj, f.name))
+
+                for f in fields(obj)
+            }
+
+        elif isinstance(obj, (list, tuple)):
+            return [cls.to_dict(item) for item in obj]
+
+        elif isinstance(obj, dict):
+            return {key: cls.to_dict(value) for key, value in obj.items()}
+
+        return obj
+
+    @classmethod
+    def to_json(cls, obj) -> str:
+        return json.dumps(cls.to_dict(obj))
+
     # constructor
 
     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:
@@ -70,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):
@@ -93,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
@@ -115,38 +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=request.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=request.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):
@@ -171,13 +220,13 @@ class DispatchMSPackChannel(HTTPXChannel):
                           args=invocation.args)
 
         try:
-            packed = msgpack.packb(request.dict(), use_bin_type=True)
+            packed = msgpack.packb(self.to_dict(request), use_bin_type=True)
 
             response = self.get_client().post(
                 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)
@@ -187,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
 
@@ -196,13 +251,13 @@ class DispatchMSPackChannel(HTTPXChannel):
                           args=invocation.args)
 
         try:
-            packed = msgpack.packb(request.dict(), use_bin_type=True)
+            packed = msgpack.packb(self.to_dict(request), use_bin_type=True)
 
             response = await self.get_async_client().post(
                 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)
@@ -212,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/registries.py

@@ -6,10 +6,10 @@ import threading
 from abc import abstractmethod
 import time
 from typing import Optional
-from urllib.parse import urlparse
 
 import consul
 
+from aspyx.di.configuration import inject_value
 from aspyx.util import StringBuilder
 from aspyx.di import on_init
 from .healthcheck import HealthCheckManager, HealthStatus
@@ -24,35 +24,38 @@ class ConsulComponentRegistry(ComponentRegistry):
     """
     # constructor
 
-    def __init__(self, port: int, consul_url: str):
+    def __init__(self, port: int, consul: consul.Consul):
         self.port = port
         self.ip = Server.get_local_ip()
         self.running = False
-        self.consul = None
+        self.consul = consul
         self.watchdog = None
         self.interval = 5
         self.last_index = {}
         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"
 
-        parsed = urlparse(consul_url)
+    # injections
 
-        self.consul_host = parsed.hostname
-        self.consul_port = parsed.port
+    @inject_value("consul.watchdog.interval", default=5)
+    def set_interval(self, interval):
+        self.watchdog_interval = interval
 
-    def make_consul(self, host="", port="") -> consul.Consul:
-        """
-        create and return a consul instance
+    @inject_value("consul.healthcheck.interval", default="10s")
+    def set_interval(self, interval):
+        self.healthcheck_interval = interval
 
-        Args:
-            host: the host
-            port: the port
+    @inject_value("consul.healthcheck.timeout", default="3s")
+    def set_interval(self, interval):
+        self.healthcheck_timeout = interval
 
-        Returns:
-            a consul instance
-
-        """
-        return consul.Consul(host=host, port=port)
+    @inject_value("consul.healthcheck.deregister", default="5m")
+    def set_interval(self, interval):
+        self.healthcheck_deregister = interval
 
     # lifecycle hooks
 
@@ -60,7 +63,6 @@ class ConsulComponentRegistry(ComponentRegistry):
     def setup(self):
         # create consul client
 
-        self.consul = self.make_consul(host=self.consul_host, port=self.consul_port)
         self.running = True
 
         # start thread
@@ -122,14 +124,12 @@ class ConsulComponentRegistry(ComponentRegistry):
 
             # time to sleep
 
-            time.sleep(5)
+            time.sleep(self.watchdog_interval)
 
     @abstractmethod
     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:
@@ -142,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:
@@ -225,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/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
 
@@ -189,21 +227,44 @@ class RestChannel(HTTPXChannel):
 
         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
 
+    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)
 
@@ -222,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/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/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="info")
+        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
 

aspyx_service/service.py

@@ -48,7 +48,12 @@ class Server(ABC):
     # constructor
 
     def __init__(self):
-        pass
+        self.environment : Optional[Environment] = None
+
+    # public
+
+    def get(self, type: Type[T]) -> T:
+        return self.environment.get(type)
 
     @abstractmethod
     def boot(self, module_type: Type):
@@ -475,6 +480,9 @@ class Channel(DynamicProxy.InvocationHandler, ABC):
         self.url_selector = Channel.FirstURLSelector()
 
     def get_url(self) -> str:
+        if self.address is None:
+            raise ServiceCommunicationException(f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+
         return self.url_selector.get(self.address.urls)
 
     def set_address(self, address: Optional[ChannelInstances]):
@@ -637,7 +645,8 @@ class ServiceManager:
     def __init__(self, component_registry: ComponentRegistry, channel_manager: ChannelManager):
         self.component_registry = component_registry
         self.channel_manager = channel_manager
-        self.environment = None
+        self.environment : Optional[Environment] = None
+        self.preferred_channel = ""
 
         self.ip = Server.get_local_ip()
 
@@ -732,6 +741,9 @@ class ServiceManager:
 
         return address
 
+    def set_preferred_channel(self, preferred_channel: str):
+        self.preferred_channel = preferred_channel
+
     def get_service(self, service_type: Type[T], preferred_channel="") -> T:
         """
         return a service proxy given a service type and preferred channel name
@@ -743,6 +755,10 @@ class ServiceManager:
         Returns:
             the proxy
         """
+
+        if len(preferred_channel) == 0:
+            preferred_channel = self.preferred_channel
+
         service_descriptor = ServiceManager.get_descriptor(service_type)
         component_descriptor = service_descriptor.get_component_descriptor()
 
@@ -850,18 +866,19 @@ class LocalChannel(Channel):
 
         return getattr(instance, invocation.method.__name__)(*invocation.args, **invocation.kwargs)
 
-
-#@injectable()
 class LocalComponentRegistry(ComponentRegistry):
     # constructor
 
     def __init__(self):
-        self.component_channels : dict[ComponentDescriptor, list[ChannelAddress]]  = {}
+        self.component_channels : dict[ComponentDescriptor, list[ChannelInstances]]  = {}
 
     # implement
 
     def register(self, descriptor: ComponentDescriptor[Component], addresses: list[ChannelAddress]) -> None:
-        self.component_channels[descriptor] = addresses
+        if self.component_channels.get(descriptor, None) is None:
+            self.component_channels[descriptor] = []
+
+        self.component_channels[descriptor].extend([ChannelInstances(descriptor.name, address.channel, [address.uri]) for address in addresses])
 
     def deregister(self, descriptor: ComponentDescriptor[Component]) -> None:
         pass

aspyx_service-0.10.2.dist-info/METADATA

@@ -0,0 +1,517 @@
+Metadata-Version: 2.4
+Name: aspyx_service
+Version: 0.10.2
+Summary: Aspyx Service framework
+Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Andreas Ernst
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: aspyx>=1.5.1
+Requires-Dist: fastapi~=0.115.13
+Requires-Dist: httpx~=0.28.1
+Requires-Dist: msgpack~=1.1.1
+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)
+- [Features](#features)
+- [Service and Component declaration](#service-and-component-declaration)
+- [Service and Component implementation](#service-and-component-implementation)
+- [Health Checks](#health-checks)
+- [Service Manager](#service-manager)
+- [Component Registry](#component-registry)
+- [Channels](#channels)
+  - [Performance](#performance)
+  - [Rest Calls](#rest-calls)
+  - [Intercepting calls](#intercepting-calls)
+- [FastAPI server](#fastapi-server)
+- [Implementing Channels](#implementing-channels)
+- [Version History](#version-history)
+
+## Introduction
+
+The Aspyx service library is built on top of the DI core framework and adds a microservice based architecture,
+that lets you deploy, discover and call services with different remoting protocols and pluggable discovery services.
+
+The basic design consists of four different concepts:
+
+!!! info "Service"
+  defines a group of methods that can be called either locally or remotely. 
+  These methods represent the functional interface exposed to clients — similar to an interface in traditional programming
+
+!!! info "Component"
+  a component bundles one or more services and declares the channels (protocols) used to expose them.
+  Think of a component as a deployment unit or module.
+
+!!! info "Component Registry "
+  acts as the central directory for managing available components.
+  It allows the framework to register, discover, and resolve components and their services.
+
+!!! info "Channel"
+  is a pluggable transport layer that defines how service method invocations are transmitted and handled.
+
+Let's look at the "interface" layer first.
+
+**Example**:
+```python
+@service(name="test-service", description="test service")
+class TestService(Service):
+    @abstractmethod
+    def hello(self, message: str) -> str:
+        pass
+
+@component(name="test-component", services =[TestService])
+class TestComponent(Component):
+    pass
+```
+
+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, "http://localhost:8500") # a consul based registry!
+
+environment = Environment(Module)
+service_manager = environment.get(ServiceManager)
+
+service = service_manager.get_service(TestService)
+
+service.hello("world")
+```
+
+The technical details are completely transparent, as a dynamic proxy encapsulates the internals.
+
+As we can also host implementations, lets look at this side as well:
+
+```python
+@implementation()
+class TestComponentImpl(AbstractComponent, TestComponent):
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+
+    # implement Component
+
+    def get_addresses(self, port: int) -> list[ChannelAddress]:
+        return [ChannelAddress("dispatch-json", f"http://{Server.get_local_ip()}:{port}")]
+
+@implementation()
+class TestServiceImpl(TestService):
+    def __init__(self):
+        pass
+
+    def hello(self, message: str) -> str:
+        return f"hello {message}"
+```
+
+The interesting part if the `get_addresses` method that return a list of channel addresses, that can be used to execute remote calls.
+In this case a channel is used that exposes a single http endpoint, that will dispatch to the correct service method.
+This information is registered with the appropriate component registry and is used by other processes. 
+
+The required - `FastAPI` - infrastructure to expose those services is started with the call:
+
+```python
+server = FastAPIServer(host="0.0.0.0", port=8000)
+
+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:
+
+```python
+ service = service_manager.get_service(TestService, preferred_channel="local")
+```
+
+## Features
+
+The library offers:
+
+- sync and async support
+- multiple - extensible - channel implementations supporting dataclasses and pydantic data models.
+- ability to customize http calls with interceptors ( via the AOP abilities )
+- `fastapi` based channels covering simple rest endpoints including `msgpack` support.
+- `httpx` based clients for dispatching channels and simple rest endpoint with the help of low-level decorators.
+- first registry implementation based on `consul`
+- support for configurable health checks
+
+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.
+
+Let's see some details
+
+## Service and Component declaration 
+
+Every service needs to inherit from the "tagging interface" `Service`
+
+```python
+@service(name="test-service", description="test service")
+class TestService(Service):
+    @abstractmethod
+    def hello(self, message: str) -> str:
+        pass
+```
+
+The decorator can add a name and a description. If `name` is not set, the class name converted to snake case is used.
+
+A component needs to derive from `Component`:
+
+```python
+@component(services =[TestService])
+class TestComponent(Component):
+    pass
+```
+
+The `services` argument references a list of service interfaces that are managed by this component, meaning that they all are 
+exposed by the same channels.
+
+`Component` defines the abstract methods:
+
+- `def startup(self) -> None`
+   called initially after booting the system
+
+- `def shutdown(self) -> None:`
+   called before shutting fown the system
+
+- `def get_addresses(self, port: int) -> list[ChannelAddress]:`
+   return  a list of available `ChannelAddress`es that this component exposes
+
+- `def get_status(self) -> ComponentStatus:`
+   return the status of this component ( one of the `ComponentStatus` enums `VIRGIN`, `RUNNING`, and `STOPPED`)
+
+- `async def get_health(self) -> HealthCheckManager.Health:`
+   return the health status of a component implementation.
+
+## Service and Component implementation
+
+Service implementations implement the corresponding interface and are decorated with `@implementation`
+
+```python
+@implementation()
+class TestServiceImpl(TestService):
+    def __init__(self):
+        pass
+```
+
+The constructor is required since the instances are managed by the DI framework.
+
+Component implementations derive from the interface and the abstract base class `AbstractComponent`
+
+```python
+@implementation()
+class TestComponentImpl(AbstractComponent, TestComponent):
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+
+    # implement Component
+
+    def get_addresses(self, port: int) -> list[ChannelAddress]:
+        return [ChannelAddress("dispatch-json", f"http://{Server.get_local_ip()}:{port}")]
+```
+
+As a minimum you have to declare the constructor and the `get_addresses` method, that exposes channel addresses
+
+## Health Checks
+
+Every component can declare a HTTP health endpoint and the corresponding logic to compute the current status.
+
+Two additional things have to be done:
+
+- adding a `@health(<endpoint>)` decorator to the class
+- implementing the `get_health()` method that returns a `HealthCheckManager.Health`
+
+While you can instantiate the `Health` class directly via
+ 
+```
+HealthCheckManager.Health(HealtStatus.OK)
+```
+
+it typically makes more sense to let the system execute a number of configured checks and compute the overall result automatically.
+
+For this purpose injectable classes can be decorated with `@health_checks()` that contain methods in turn decorated with `@health_check`
+
+**Example**:
+
+```python
+@health_checks()
+@injectable()
+class Checks:
+    def __init__(self):
+        pass
+
+    @health_check(fail_if_slower_than=1)
+    def check_performance(self, result: HealthCheckManager.Result):
+        ... # should be done in under a second
+
+    @health_check(name="check", cache=10)
+    def check(self, result: HealthCheckManager.Result):
+        ok = ...
+        result.set_status(if ok HealthStatus.OK else HealthStatus.ERROR)
+```
+
+The methods are expected to have a single parameter of type `HealthCheckManager.Result` that can be used to set the status including detail information with
+
+```
+set_status(status: HealthStatus, details = "")
+```
+
+When called, the default is already `OK`.
+
+The decorator accepts a couple of parameters:
+
+- `fail_if_slower_than=0` 
+   time in `s` that the check is expected to take as a maximum. As soon as the time is exceeded, the status is set to `ERROR`
+- `cache`
+   time in 's' that the last result is cached. This is done in order to prevent health-checks putting even more strain on a heavily used system.
+
+## Service Manager
+
+`ServiceManager` is the central class used to retrieve service proxies.
+
+```python
+def get_service(self, service_type: Type[T], preferred_channel="") -> T
+```
+
+- `type` is the requested service interface
+- `preferred_channel` the name of the preferred channel.
+
+If not specified, the first registered channel is used, which btw. is a local channel - called `local` -  in case of implementing services.
+
+## Component Registry
+
+The component registry is the place where component implementations are registered and retrieved.
+
+In addition to a `LocalComponentRegistry` ( which is used for testing purposes ) the only implementation is
+
+`ConsulComponentRegistry`
+
+Constructor arguments are
+
+- `port: int` the own port
+- `consul: Consul` the consul instance
+
+The component registry is also responsible to execute regular health-checks to track component healths.
+As soon as - in our case consul - decides that a component is not alive anymore, it will notify the clients via regular heartbeats about address changes
+which will be propagated to channels talking to the appropriate component.
+
+Currently, this only affects the list of possible URLs which are required by the channels!
+
+## Channels
+
+Channels implement the possible transport layer protocols. In the sense of a dynamic proxy, they are the invocation handlers!
+
+Several channels are implemented:
+
+- `dispatch-json`
+   channel that dispatches 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
+- `rest`
+  channel that executes regular rest-calls as defined by a couple of 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
+
+- `FirstURLSelector` always returns the first URL of the list of possible URLs
+- `RoundRobinURLSelector` switches sequentially between all URLs.
+
+To customize the behavior, an around advice can be implemented easily:
+
+**Example**:
+ 
+```python
+@advice
+class ChannelAdvice:
+    def __init__(self):
+        pass
+
+@advice
+class ChannelAdvice:
+    def __init__(self):
+        pass
+
+    @around(methods().named("customize").of_type(Channel))
+    def customize_channel(self, invocation: Invocation):
+        channel = cast(Channel, invocation.args[0])
+
+        channel.select_round_robin() # or select_first_url()
+
+        return invocation.proceed()
+```
+
+### Performance
+
+I benchmarked the different implementations with a recursive dataclass as an argument and return value.
+The avg response times - on a local server - where all below 1ms per call.
+
+- rest calls are the slowest ( about 0.7ms )
+- dispatching-json 20% faster
+- dispatching-msgpack 30% faster
+
+The biggest advantage of the dispatching flavors is, that you don't have to worry about the additional decorators!
+
+### Rest Calls
+
+Invoking rest calls requires decorators and some marker annotations.
+
+**Example**:
+
+```python
+@service()
+@rest("/api")
+class TestService(Service):
+    @get("/hello/{message}")
+    def hello(self, message: str) -> str:
+        pass
+
+    @post("/post/")
+    def set_data(self, data: Body(Data)) -> Data:
+        pass
+```
+
+The decorators `get`,  `put`,  `post` and  `delete` specify the methods.
+
+If the class is decorated with `@rest(<prefix>)`, the corresponding prefix will be appended at the beginning.
+
+Additional annotations are
+- `Body` the post body
+- `QueryParam`marked for query params
+
+### Intercepting calls
+
+The client side HTTP calling is done with `httpx` instances of type `Httpx.Client` or `Httpx.AsyncClient`.
+
+To add the possibility to add interceptors - for token handling, etc. - the channel base class `HTTPXChannel` defines
+the methods `make_client()` and `make_async_client` that can be modified with an around advice.
+
+**Example**:
+
+```python
+class InterceptingClient(httpx.Client):
+    # constructor
+
+    def __init__(self, *args, **kwargs):
+        self.token_provider = ...
+        super().__init__(*args, **kwargs)
+
+    # override
+
+    def request(self, method, url, *args, **kwargs):
+        headers = kwargs.pop("headers", {})
+        headers["Authorization"] = f"Bearer {self.token_provider()}"
+        kwargs["headers"] = headers
+
+        return super().request(method, url, *args, **kwargs)
+    
+@advice
+class ChannelAdvice:
+    def __init__(self):
+        pass
+
+    @around(methods().named("make_client").of_type(HTTPXChannel))
+    def make_client(self, invocation: Invocation):
+        return InterceptingClient()
+```
+
+## FastAPI server
+
+In order to expose components via HTTP, the corresponding infrastructure in form of a FastAPI server needs to be setup. 
+
+
+```python
+@module()
+class Module():
+    def __init__(self):
+        pass
+    
+ server = FastAPIServer(host="0.0.0.0", port=8000)
+
+ environment = server.boot(Module) # will start the http server
+```
+
+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! 
+
+## 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)
+and decorate it with `@channel(<name>)`
+
+The main methods to implement are `ìnvoke` and `ìnvoke_async`
+
+**Example**:
+
+```python
+@channel("fancy")
+class FancyChannel(Channel):
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+
+    # override
+
+    def invoke(self, invocation: DynamicProxy.Invocation):
+        return ...
+    
+     async def invoke_async(self, invocation: DynamicProxy.Invocation):
+        return await ...
+        
+```
+
+# Version History
+
+**0.10.0**
+
+- first release version
+
+
+
+
+

aspyx_service-0.10.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+aspyx_service/__init__.py,sha256=6t24VPrSCG83EAvYlqCKdEcEbyCY3vrSb5GoAx01Ymg,1662
+aspyx_service/channels.py,sha256=9EjnY6DV_toqeQNswYZgmAtirXM_TTLGErs6hb1U9yw,8934
+aspyx_service/healthcheck.py,sha256=8ZPSkAx6ypoYaxDMkJT_MtL2pEN2LcUAishAWPCy-3I,5624
+aspyx_service/registries.py,sha256=JSsD32F8VffZMHyEDuapEWtvmem5SK9kR6bgsFRLFZQ,8002
+aspyx_service/restchannel.py,sha256=OVGyKNtORJEFnWsFB5MPkNldVFfJTGuUa4X658_x9Kg,9169
+aspyx_service/serialization.py,sha256=lEr106yiZ0UzVxGTGdiorZSSSNI7vP4C7RyrBJku-U0,4133
+aspyx_service/server.py,sha256=PHKx3O90jnxm8dA4z331_51znhU-HlRB2Fa1AikmFXA,7052
+aspyx_service/service.py,sha256=-hhxRpEtMn-JP57bHNF521zbGMHUy5YaXkbXyiu7dW4,25927
+aspyx_service-0.10.2.dist-info/METADATA,sha256=KEdh30D63sXs26FVOtCph_LF521bBJa7A6Qpc8d-9iQ,16966
+aspyx_service-0.10.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aspyx_service-0.10.2.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx_service-0.10.2.dist-info/RECORD,,

aspyx_service-0.10.0.dist-info/METADATA

@@ -1,37 +0,0 @@
-Metadata-Version: 2.4
-Name: aspyx_service
-Version: 0.10.0
-Summary: Aspyx Service framework
-Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2025 Andreas Ernst
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-License-File: LICENSE
-Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.5.0
-Requires-Dist: fastapi~=0.115.13
-Requires-Dist: httpx~=0.28.1
-Requires-Dist: msgpack~=1.1.1
-Requires-Dist: python-consul2~=0.1.5
-Requires-Dist: uvicorn[standard]
-Description-Content-Type: text/markdown
-
-aspyx-service

aspyx_service-0.10.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-aspyx_service/__init__.py,sha256=6t24VPrSCG83EAvYlqCKdEcEbyCY3vrSb5GoAx01Ymg,1662
-aspyx_service/channels.py,sha256=HZFkbZq0Q1DNpOauuPCMOEh7UlpcisN8_gQhL66zS-0,7718
-aspyx_service/healthcheck.py,sha256=8ZPSkAx6ypoYaxDMkJT_MtL2pEN2LcUAishAWPCy-3I,5624
-aspyx_service/registries.py,sha256=5sU9eFT_D33sAgrXyYSd9fAa8xNmFRJ6CmZGp8cQztY,7712
-aspyx_service/restchannel.py,sha256=IbspE-hrzkpPLgBzuNncagjjGZnLVPX9jtT1PKRNenw,6453
-aspyx_service/serialization.py,sha256=T6JDURwYd7V4240j1BnNsFKdyiMgePCsCwKa9rf8hq4,3779
-aspyx_service/server.py,sha256=DA4bfTzYbpPrfqgddbyvTqr80Ehk9tuoqFfuo59ppN4,7118
-aspyx_service/service.py,sha256=T7rZ8EPEzOusP_xOk-7KwTQfX_iJQ291XDL_ieKa_d8,25148
-aspyx_service-0.10.0.dist-info/METADATA,sha256=9bVUDpfMPvHUr_NfWmOw4EYHA0rw8m84niRWxnhmslk,1674
-aspyx_service-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aspyx_service-0.10.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx_service-0.10.0.dist-info/RECORD,,