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

aspyx_service/channels.py

@@ -11,8 +11,10 @@ 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 aspyx.threading import ThreadLocal
+from .service import ServiceManager, ServiceCommunicationException
 
 from .service import ComponentDescriptor, ChannelInstances, ServiceException, channel, Channel, RemoteServiceException
 from .serialization import get_deserializer
@@ -23,9 +25,15 @@ class HTTPXChannel(Channel):
         "client",
         "async_client",
         "service_names",
-        "deserializers"
+        "deserializers",
+        "timeout"
     ]
 
+    # class properties
+
+    client_local = ThreadLocal[Client]()
+    async_client_local = ThreadLocal[AsyncClient]()
+
     # class methods
 
     @classmethod
@@ -58,11 +66,16 @@ class HTTPXChannel(Channel):
     def __init__(self):
         super().__init__()
 
-        self.client: Optional[Client] = None
-        self.async_client: Optional[AsyncClient] = None
+        self.timeout = 1000.0
         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:
@@ -86,29 +99,30 @@ class HTTPXChannel(Channel):
         for service in component_descriptor.services:
             self.service_names[service.type] = service.name
 
-        # make client
-
-        self.client = self.make_client()
-        self.async_client = self.make_async_client()
-
     # public
 
     def get_client(self) -> Client:
-        if self.client is None:
-            self.client = self.make_client()
+        client = self.client_local.get()
+
+        if client is None:
+            client = self.make_client()
+            self.client_local.set(client)
 
-        return self.client
+        return client
 
-    def get_async_client(self) -> Client:
-        if self.async_client is None:
-            self.async_client = self.make_async_client()
+    def get_async_client(self) -> AsyncClient:
+        async_client = self.async_client_local.get()
 
-        return self.async_client
+        if async_client is None:
+            async_client = self.make_async_client()
+            self.async_client_local.set(async_client)
 
-    def make_client(self):
+        return async_client
+
+    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 +136,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 +158,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 +231,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 +241,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 +262,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 +272,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,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/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,41 @@ 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_async_client().get(self.get_url() + url, params=query_params, timeout=self.timeout)
+            elif call.type == "put":
+                result = await self.get_async_client().put(self.get_url() + url, params=query_params, timeout=self.timeout)
+            elif call.type == "delete":
+                result = await self.get_async_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout)
+            elif call.type == "post":
+                result = await self.get_async_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
+
+            return self.get_deserializer(invocation.type, invocation.method)(result.json())
+        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 +282,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)
+            elif call.type == "put":
+                result = self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout)
+            elif call.type == "delete":
+                result = self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout)
+            elif call.type == "post":
+                result = self.get_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
+
+            return self.get_deserializer(invocation.type, invocation.method)(result.json())
+        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
 
@@ -103,6 +42,9 @@ class TypeDeserializer:
         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()
                 })
@@ -119,6 +61,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 +122,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="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
 

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()
 
@@ -753,11 +769,12 @@ class ServiceManager:
 
         # check proxy
 
-        key = TypeAndChannel(type=component_descriptor.type, channel=preferred_channel)
+        channel_key = TypeAndChannel(type=component_descriptor.type, channel=preferred_channel)
+        proxy_key   = TypeAndChannel(type=service_type, channel=preferred_channel)
 
-        proxy = self.proxy_cache.get(key, None)
+        proxy = self.proxy_cache.get(proxy_key, None)
         if proxy is None:
-            channel_instance = self.channel_cache.get(key, None)
+            channel_instance = self.channel_cache.get(channel_key, None)
 
             if channel_instance is None:
                 address = self.find_service_address(component_descriptor, preferred_channel)
@@ -770,9 +787,9 @@ class ServiceManager:
                 # channel may have changed
 
                 if address.channel != preferred_channel:
-                    key = TypeAndChannel(type=component_descriptor.type, channel=address.channel)
+                    channel_key = TypeAndChannel(type=component_descriptor.type, channel=address.channel)
 
-                channel_instance = self.channel_cache.get(key, None)
+                channel_instance = self.channel_cache.get(channel_key, None)
                 if channel_instance is None:
                     # create channel
 
@@ -780,7 +797,7 @@ class ServiceManager:
 
                     # cache
 
-                    self.channel_cache[key] =  channel_instance
+                    self.channel_cache[channel_key] =  channel_instance
 
                     # and watch for changes in the addresses
 
@@ -789,7 +806,7 @@ class ServiceManager:
             # create proxy
 
             proxy = DynamicProxy.create(service_type, channel_instance)
-            self.proxy_cache[key] = proxy
+            self.proxy_cache[proxy_key] = proxy
 
         return proxy
 
@@ -850,18 +867,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.1.dist-info → aspyx_service-0.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.1
+Version: 0.10.3
 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)
@@ -58,19 +70,23 @@ that lets you deploy, discover and call services with different remoting protoco
 
 The basic design consists of four different concepts:
 
-!!! info "Service"
+**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"
+**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 "
+**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"
+**Channel**
+
   is a pluggable transport layer that defines how service method invocations are transmitted and handled.
 
 Let's look at the "interface" layer first.
@@ -99,7 +115,7 @@ class Module:
     
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
-        return ConsulComponentRegistry(Server.port, "http://localhost: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)
@@ -349,7 +365,7 @@ A so called `URLSelector` is used internally to provide URLs for every single ca
 - `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:
+To customize the behavior, an `around` advice can be implemented easily:
 
 **Example**:
  

aspyx_service-0.10.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

aspyx_service-0.10.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-aspyx_service/__init__.py,sha256=6t24VPrSCG83EAvYlqCKdEcEbyCY3vrSb5GoAx01Ymg,1662
-aspyx_service/channels.py,sha256=ts-LgqIgt02W72cMS1LrimOCyKHfpzL3BC7s2vFjWFs,8492
-aspyx_service/healthcheck.py,sha256=8ZPSkAx6ypoYaxDMkJT_MtL2pEN2LcUAishAWPCy-3I,5624
-aspyx_service/registries.py,sha256=4PvMZaFolZH0D2GD6NWXlmaOXJ2kQxuWEBMwoQqsJRg,7473
-aspyx_service/restchannel.py,sha256=d7j7z6T3HQ7oj_KJ9aLrmoJpmSRqa6cNh7o_IkCIfBg,6096
-aspyx_service/serialization.py,sha256=T6JDURwYd7V4240j1BnNsFKdyiMgePCsCwKa9rf8hq4,3779
-aspyx_service/server.py,sha256=wEl1Y_2aolG3n4w4qUtl8X4_anjd_m9WYMT2twModv8,7119
-aspyx_service/service.py,sha256=T7rZ8EPEzOusP_xOk-7KwTQfX_iJQ291XDL_ieKa_d8,25148
-aspyx_service-0.10.1.dist-info/METADATA,sha256=PbMCzxd082R1yuesNe2sjqYENT1NNm_3fHaHcd46rho,16249
-aspyx_service-0.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aspyx_service-0.10.1.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx_service-0.10.1.dist-info/RECORD,,