aspyx-service 0.11.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

aspyx_service/channels.py

@@ -16,7 +16,7 @@ from pydantic import BaseModel
 from aspyx.di.configuration import inject_value
 from aspyx.reflection import DynamicProxy, TypeDescriptor
 from aspyx.threading import ThreadLocal, ContextLocal
-from aspyx.util import get_deserializer, TypeDeserializer, TypeSerializer, get_serializer
+from aspyx.util import get_deserializer, TypeDeserializer, TypeSerializer, get_serializer, CopyOnWriteCache
 from .service import ServiceManager, ServiceCommunicationException, TokenExpiredException, InvalidTokenException, \
     AuthorizationException, MissingTokenException
 
@@ -61,6 +61,9 @@ class TokenContext:
             cls.refresh_token.reset(refresh_token)
 
 class HTTPXChannel(Channel):
+    """
+    A channel using the httpx clients.
+    """
     __slots__ = [
         "client",
         "async_client",
@@ -75,28 +78,6 @@ class HTTPXChannel(Channel):
     client_local = ThreadLocal[Client]()
     async_client_local = ThreadLocal[AsyncClient]()
 
-    # class methods
-
-    @classmethod
-    def to_dict(cls, obj: Any) -> Any:
-        if isinstance(obj, BaseModel):
-            return obj.model_dump()
-
-        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
-
     # constructor
 
     def __init__(self):
@@ -104,9 +85,8 @@ class HTTPXChannel(Channel):
 
         self.timeout = 1000.0
         self.service_names: dict[Type, str] = {}
-        self.serializers: dict[Callable, list[Callable]] = {}
-        self.deserializers: dict[Callable, Callable] = {}
-        self.optimize_serialization = True
+        self.serializers = CopyOnWriteCache[Callable, list[Callable]]()
+        self.deserializers = CopyOnWriteCache[Callable, Callable]()
 
     # inject
 
@@ -132,7 +112,7 @@ class HTTPXChannel(Channel):
 
             serializers = [get_serializer(type) for type in param_types]
 
-            self.serializers[method] = serializers
+            self.serializers.put(method, serializers)
 
         return serializers
 
@@ -143,7 +123,7 @@ class HTTPXChannel(Channel):
 
             deserializer = get_deserializer(return_type)
 
-            self.deserializers[method] = deserializer
+            self.deserializers.put(method, deserializer)
 
         return deserializer
 
@@ -196,32 +176,6 @@ class HTTPXChannel(Channel):
 
             headers["Authorization"] = f"Bearer {token}"
 
-        ### TEST
-
-        print_size = False
-        if print_size:
-            request = self.get_client().build_request(http_method, url, params=params, json=json, headers=headers, timeout=timeout, content=content)
-            # Measure body
-            body_size = len(request.content or b"")
-
-            # Measure headers (as raw bytes)
-            headers_size = sum(
-                len(k.encode()) + len(v.encode()) + 4  # ": " + "\r\n"
-                for k, v in request.headers.items()
-            ) + 2  # final \r\n
-
-            # Optional: estimate request line
-            request_line = f"{request.method} {request.url.raw_path.decode()} HTTP/1.1\r\n".encode()
-            request_line_size = len(request_line)
-
-            # Total estimated size
-            total_size = request_line_size + headers_size + body_size
-
-            print(f"Request line: {request_line_size} bytes")
-            print(f"Headers: {headers_size} bytes")
-            print(f"Body: {body_size} bytes")
-            print(f"Total request size: {total_size} bytes")
-
         try:
             response = self.get_client().request(http_method, url, params=params, json=json, headers=headers, timeout=timeout, content=content)
             response.raise_for_status()
@@ -317,16 +271,11 @@ class DispatchJSONChannel(HTTPXChannel):
     def invoke(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
 
-        request : dict = {
-            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}"
-            #"args": invocation.args
+        request = {
+            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+            "args": self.serialize_args(invocation)
         }
 
-        if self.optimize_serialization:
-            request["args"] = self.serialize_args(invocation)
-        else:
-            request["args"] = self.to_dict(invocation.args)
-
         try:
             http_result = self.request( "post", f"{self.get_url()}/invoke", json=request, timeout=self.timeout)
             result = http_result.json()
@@ -343,15 +292,11 @@ class DispatchJSONChannel(HTTPXChannel):
 
     async def invoke_async(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
-        request : dict = {
-            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}"
+        request = {
+            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+            "args": self.serialize_args(invocation)
         }
 
-        if self.optimize_serialization:
-            request["args"] = self.serialize_args(invocation)
-        else:
-            request["args"] = self.to_dict(invocation.args)
-
         try:
             data =  await self.request_async("post", f"{self.get_url()}/invoke", json=request, timeout=self.timeout)
             result = data.json()
@@ -387,15 +332,11 @@ class DispatchMSPackChannel(HTTPXChannel):
 
     def invoke(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
-        request: dict = {
-            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}"
+        request = {
+            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+            "args": self.serialize_args(invocation)
         }
 
-        if self.optimize_serialization:
-            request["args"] = self.serialize_args(invocation)
-        else:
-            request["args"] = self.to_dict(invocation.args)
-
         try:
             packed = msgpack.packb(request, use_bin_type=True)
 
@@ -444,15 +385,11 @@ class DispatchMSPackChannel(HTTPXChannel):
 
     async def invoke_async(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
-        request: dict = {
-            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}"
+        request = {
+            "method": f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+            "args": self.serialize_args(invocation)
         }
 
-        if self.optimize_serialization:
-            request["args"] = self.serialize_args(invocation)
-        else:
-            request["args"] = self.to_dict(invocation.args)
-
         try:
             packed = msgpack.packb(request, use_bin_type=True)
 

aspyx_service/protobuf.py

@@ -4,10 +4,11 @@ Protobuf channel and utilities
 from __future__ import annotations
 
 import inspect
+import logging
 import threading
 from dataclasses import is_dataclass, fields as dc_fields
 from typing import Type, get_type_hints, Callable, Tuple, get_origin, get_args, List, Dict, Any, Union, Sequence, \
-    Optional
+    Optional, cast
 
 import httpx
 from google.protobuf.message_factory import GetMessageClass
@@ -17,12 +18,13 @@ from google.protobuf import descriptor_pb2, descriptor_pool, message_factory
 from google.protobuf.descriptor_pool import DescriptorPool
 from google.protobuf.message import Message
 from google.protobuf.descriptor import FieldDescriptor, Descriptor
+from starlette.responses import PlainTextResponse
 
-from aspyx.di import injectable
+from aspyx.di import injectable, Environment
 from aspyx.reflection import DynamicProxy, TypeDescriptor
-from aspyx.util import CopyOnWriteCache
+from aspyx.util import CopyOnWriteCache, StringBuilder
 
-from .service import channel, ServiceException
+from .service import channel, ServiceException, Server, ComponentDescriptor
 from .channels import HTTPXChannel
 from .service  import ServiceManager, ServiceCommunicationException, AuthorizationException, RemoteServiceException
 
@@ -53,6 +55,11 @@ def defaults_dict(model_cls: Type[BaseModel]) -> dict[str, Any]:
     return result
 
 class ProtobufBuilder:
+    """
+    used to infer protobuf services and messages given component and service structures.
+    """
+    logger = logging.getLogger("aspyx.service.protobuf")  #
+
     # slots
 
     __slots__ = [
@@ -72,11 +79,11 @@ class ProtobufBuilder:
 
     @classmethod
     def get_request_message_name(cls, type: Type, method: Callable) -> str:
-        return cls.get_message_name(type, f"{method.__name__}Request")
+        return cls.get_message_name(type, f"_{method.__name__}_Request")
 
     @classmethod
     def get_response_message_name(cls, type: Type, method: Callable) -> str:
-        return cls.get_message_name(type, f"{method.__name__}Response")
+        return cls.get_message_name(type, f"_{method.__name__}_Response")
 
     # local classes
 
@@ -90,7 +97,7 @@ class ProtobufBuilder:
             self.file_desc_proto.name = f"{self.name}.proto"
             self.file_desc_proto.package = self.name
             self.types : dict[Type, Any] = {}
-            self.finalized = False
+            self.sealed = False
             self.lock = threading.RLock()
 
         # public
@@ -107,12 +114,16 @@ class ProtobufBuilder:
             raise TypeError("Expected a dataclass or Pydantic model class.")
 
         def add_message(self, cls: Type) -> str:
-            if self.finalized:
+            if self.sealed:
                 raise ServiceException(f"module {self.name} is already sealed")
 
+
+
             name = cls.__name__
             full_name = f"{self.name}.{name}"
 
+            ProtobufBuilder.logger.debug(f"adding message %s", full_name)
+
             # Check if a message type is already defined
 
             if any(m.name == name for m in self.file_desc_proto.message_type):
@@ -154,12 +165,14 @@ class ProtobufBuilder:
             return self.types[type]
 
         def build_request_message(self, method: TypeDescriptor.MethodDescriptor, request_name: str):
-            if self.finalized:
+            if self.sealed:
                 raise ServiceException(f"module {self.name} is already sealed")
 
             request_msg = descriptor_pb2.DescriptorProto()  # type: ignore
             request_msg.name = request_name.split(".")[-1]
 
+            ProtobufBuilder.logger.debug(f"adding request message %s", request_msg.name)
+
             # loop over parameters
 
             field_index = 1
@@ -182,12 +195,14 @@ class ProtobufBuilder:
             self.file_desc_proto.message_type.add().CopyFrom(request_msg)
 
         def build_response_message(self, method: TypeDescriptor.MethodDescriptor, response_name: str):
-            if self.finalized:
+            if self.sealed:
                 raise ServiceException(f"module {self.name} is already sealed")
 
             response_msg = descriptor_pb2.DescriptorProto()  # type: ignore
             response_msg.name = response_name.split(".")[-1]
 
+            ProtobufBuilder.logger.debug(f"adding response message %s", response_msg.name)
+
             # return
 
             return_type = method.return_type
@@ -218,13 +233,13 @@ class ProtobufBuilder:
             self.file_desc_proto.message_type.add().CopyFrom(response_msg)
 
         def build_service_method(self, service_desc: descriptor_pb2.ServiceDescriptorProto, service_type: TypeDescriptor, method: TypeDescriptor.MethodDescriptor):
-            name = f"{service_type.cls.__name__}{method.get_name()}"
+            name = f"{service_type.cls.__name__}_{method.get_name()}"
             package = self.name
 
             method_desc =  descriptor_pb2.MethodDescriptorProto()
 
-            request_name = f".{package}.{name}Request"
-            response_name = f".{package}.{name}Response"
+            request_name = f".{package}.{name}_Request"
+            response_name = f".{package}.{name}_Response"
 
             method_desc.name = method.get_name()
             method_desc.input_type = request_name
@@ -240,12 +255,14 @@ class ProtobufBuilder:
             service_desc.method.add().CopyFrom(method_desc)
 
         def add_service(self, service_type: TypeDescriptor):
-            if self.finalized:
+            if self.sealed:
                 raise ServiceException(f"module {self.name} is already sealed")
 
             service_desc = descriptor_pb2.ServiceDescriptorProto()  # type: ignore
             service_desc.name = service_type.cls.__name__
 
+            ProtobufBuilder.logger.debug(f"add service %s", service_desc.name)
+
             # check methods
 
             for method in service_type.get_methods():
@@ -255,17 +272,16 @@ class ProtobufBuilder:
 
             self.file_desc_proto.service.add().CopyFrom(service_desc)
 
-        def finalize(self, builder: ProtobufBuilder):
-            if not self.finalized:
-                self.finalized = True
+        def seal(self, builder: ProtobufBuilder):
+            if not self.sealed:
+                ProtobufBuilder.logger.debug(f"create protobuf {self.file_desc_proto.name}")
 
-                #for m in self.file_desc_proto.message_type:
-                #    print(m)
+                self.sealed = True
 
                 # add dependency first
 
                 for dependency in self.file_desc_proto.dependency:
-                    builder.modules[dependency].finalize(builder)
+                    builder.modules[dependency].seal(builder)
 
                 builder.pool.Add(self.file_desc_proto)
 
@@ -340,7 +356,6 @@ class ProtobufBuilder:
 
     def get_message_type(self, full_name: str):
         return GetMessageClass(self.pool.FindMessageTypeByName(full_name))
-        #return self.factory.GetPrototype(self.pool.FindMessageTypeByName(full_name))
 
     def get_request_message(self, type: Type, method: Callable):
         return self.get_message_type(self.get_request_message_name(type, method))
@@ -364,11 +379,7 @@ class ProtobufBuilder:
     # public
 
     #@synchronized()
-    def check(self, service_type: Type):
-        descriptor = getattr(service_type, "__descriptor__")
-
-        component_descriptor = descriptor.component_descriptor
-
+    def prepare_component(self, component_descriptor: ComponentDescriptor):
         with self.lock:
             if component_descriptor not in self.components:
                 for service in component_descriptor.services:
@@ -377,7 +388,7 @@ class ProtobufBuilder:
                 # finalize
 
                 for module in self.modules.values():
-                    module.finalize(self)
+                    module.seal(self)
 
                 # done
 
@@ -799,54 +810,41 @@ class ProtobufManager(ProtobufBuilder):
     # public
 
     def create_serializer(self, type: Type, method: Callable) -> ProtobufManager.MethodSerializer:
-        # is it cached?
-
-        serializer = self.serializer_cache.get(method)
-        if serializer is None:
-            self.check(type)  # make sure all messages are created
-
-            serializer = ProtobufManager.MethodSerializer(self, self.get_request_message(type, method)).args(method)
-
-            self.serializer_cache.put(method, serializer)
-
-        return serializer
+        return self.serializer_cache.get(method, lambda m: ProtobufManager.MethodSerializer(self, self.get_request_message(type, m)).args(m) )
 
     def create_deserializer(self, descriptor: Descriptor, method: Callable) -> ProtobufManager.MethodDeserializer:
-        # is it cached?
-
-        deserializer = self.deserializer_cache.get(descriptor)
-        if deserializer is None:
-            deserializer = ProtobufManager.MethodDeserializer(self, descriptor).args(method)
-
-            self.deserializer_cache.put(descriptor, deserializer)
-
-        return deserializer
+        return self.deserializer_cache.get(descriptor, lambda d:  ProtobufManager.MethodDeserializer(self, d).args(method))
 
     def create_result_serializer(self, descriptor: Descriptor, method: Callable) -> ProtobufManager.MethodSerializer:
-        # is it cached?
+        return self.result_serializer_cache.get(descriptor, lambda d: ProtobufManager.MethodSerializer(self, d).result(method))
 
-        serializer = self.result_serializer_cache.get(descriptor)
-        if serializer is None:
-            serializer = ProtobufManager.MethodSerializer(self, descriptor).result(method)
+    def create_result_deserializer(self, descriptor: Descriptor, method: Callable) -> ProtobufManager.MethodDeserializer:
+        return  self.result_deserializer_cache.get(descriptor, lambda d: ProtobufManager.MethodDeserializer(self, d).result(method))
 
-            self.result_serializer_cache.put(descriptor, serializer)
+    def report(self) -> str:
+        builder = StringBuilder()
+        for module in self.modules.values():
+            builder.append(ProtobufDumper.dump_proto(module.file_desc_proto))
 
-        return serializer
+        return str(builder)
 
-    def create_result_deserializer(self, descriptor: Descriptor,
-                                   method: Callable) -> ProtobufManager.MethodDeserializer:
-        # is it cached?
+@channel("dispatch-protobuf")
+class ProtobufChannel(HTTPXChannel):
+    """
+    channel, encoding requests and responses with protobuf
+    """
+    # class methods
 
-        deserializer = self.result_deserializer_cache.get(descriptor)
-        if deserializer is None:
-            deserializer = ProtobufManager.MethodDeserializer(self, descriptor).result(method)
+    @classmethod
+    def prepare(cls,  server: Server, component_descriptor: ComponentDescriptor):
+        protobuf_manager = server.get(ProtobufManager)
+        protobuf_manager.prepare_component(component_descriptor)
 
-            self.result_deserializer_cache.put(descriptor, deserializer)
+        def report_protobuf():
+            return protobuf_manager.report()
 
-        return deserializer
+        server.add_route(path="/report-protobuf", endpoint=report_protobuf, methods=["GET"], response_class=PlainTextResponse)
 
-@channel("dispatch-protobuf")
-class ProtobufChannel(HTTPXChannel):
     # local classes
 
     class Call:
@@ -896,6 +894,12 @@ class ProtobufChannel(HTTPXChannel):
         self.protobuf_manager = protobuf_manager
         self.cache = CopyOnWriteCache[Callable, ProtobufChannel.Call]()
 
+        # make sure, all protobuf messages are created
+
+        for descriptor in manager.descriptors.values():
+            if descriptor.is_component():
+                protobuf_manager.prepare_component(cast(ComponentDescriptor, descriptor))
+
     # internal
 
     def get_call(self, type: Type, method: Callable) -> ProtobufChannel.Call:
@@ -973,6 +977,7 @@ class ProtobufDumper:
             lines.append('')  # blank line
 
         # Options (basic)
+
         for opt in fd.options.ListFields() if fd.HasField('options') else []:
             # Just a simple string option dump; for complex options you'd need more logic
             name = opt[0].name
@@ -982,6 +987,7 @@ class ProtobufDumper:
             lines.append('')
 
         # Enums
+
         def dump_enum(enum: descriptor_pb2.EnumDescriptorProto, indent=''):
             enum_lines = [f"{indent}enum {enum.name} {{"]
             for value in enum.value:
@@ -990,6 +996,7 @@ class ProtobufDumper:
             return enum_lines
 
         # Messages (recursive)
+
         def dump_message(msg: descriptor_pb2.DescriptorProto, indent=''):
             msg_lines = [f"{indent}message {msg.name} {{"]
             # Nested enums
@@ -997,6 +1004,7 @@ class ProtobufDumper:
                 msg_lines.extend(dump_enum(enum, indent + '  '))
 
             # Nested messages
+
             for nested in msg.nested_type:
                 # skip map entry messages (synthetic)
                 if nested.options.map_entry:
@@ -1004,6 +1012,7 @@ class ProtobufDumper:
                 msg_lines.extend(dump_message(nested, indent + '  '))
 
             # Fields
+
             for field in msg.field:
                 label = {
                     1: 'optional',
@@ -1054,6 +1063,7 @@ class ProtobufDumper:
             return msg_lines
 
         # Services
+
         def dump_service(svc: descriptor_pb2.ServiceDescriptorProto, indent=''):
             svc_lines = [f"{indent}service {svc.name} {{"]
             for method in svc.method:

aspyx_service/server.py

@@ -14,14 +14,14 @@ import msgpack
 import uvicorn
 
 from fastapi import FastAPI, APIRouter, Request as HttpRequest, Response as HttpResponse, HTTPException
-
+from fastapi.datastructures import DefaultPlaceholder, Default
 
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from aspyx.di import Environment, on_init, inject_environment, on_destroy
 from aspyx.reflection import TypeDescriptor, Decorators
-from aspyx.util import get_deserializer, get_serializer
+from aspyx.util import get_deserializer, get_serializer, CopyOnWriteCache
 
 from .protobuf import ProtobufManager
 from .service import ComponentRegistry, ServiceDescriptor
@@ -192,7 +192,7 @@ class FastAPIServer(Server):
 
         # cache
 
-        self.deserializers: dict[str, list[Callable]] = {}
+        self.deserializers = CopyOnWriteCache[str, list[Callable]]()
 
         # that's the overall dispatcher
 
@@ -328,18 +328,16 @@ class FastAPIServer(Server):
         self.thread.start()
 
     def get_deserializers(self, service: Type, method):
-        deserializers = self.deserializers.get(method, None)
+        deserializers = self.deserializers.get(method)
         if deserializers is None:
             descriptor = TypeDescriptor.for_type(service).get_method(method.__name__)
 
             deserializers = [get_deserializer(type) for type in descriptor.param_types]
-            self.deserializers[method] = deserializers
+            self.deserializers.put(method, deserializers)
 
         return deserializers
 
     def deserialize_args(self, args: list[Any], type: Type, method: Callable) -> list:
-        #args = list(request.args)
-
         deserializers = self.get_deserializers(type, method)
 
         for i, arg in enumerate(args):
@@ -354,98 +352,93 @@ class FastAPIServer(Server):
         service_name = parts[1]
         method_name = parts[2]
 
-        service_descriptor : ServiceDescriptor = typing.cast(ServiceDescriptor, ServiceManager.descriptors_by_name[service_name])
+        service_descriptor = typing.cast(ServiceDescriptor, ServiceManager.descriptors_by_name[service_name])
         service = self.service_manager.get_service(service_descriptor.type, preferred_channel="local")
 
         return service_descriptor, getattr(service, method_name)
 
-    async def invoke(self, http_request: HttpRequest):
-        content_type = http_request.headers.get("content-type", "")
-        response_name = ""
+    async def invoke_json(self, http_request: HttpRequest):
+        data = await http_request.json()
+        service_descriptor, method = self.get_descriptor_and_method(data["method"])
+        args = self.deserialize_args(data["args"], service_descriptor.type, method)
 
-        service_descriptor : ServiceDescriptor
-        method : Callable
-        args : list[Any]
+        try:
+            result = await self.dispatch(service_descriptor, method, args)
 
-        content = "json"
-        if "application/msgpack" in content_type:
-            content = "msgpack"
-            data = msgpack.unpackb(await http_request.body(), raw=False)
-            service_descriptor, method = self.get_descriptor_and_method(data["method"])
-            args = self.deserialize_args(data["args"], service_descriptor.type, method)
+            return Response(result=result, exception=None).model_dump()
+        except Exception as e:
+            return Response(result=None, exception=str(e)).model_dump()
 
-        elif "application/json" in content_type:
-            data = await http_request.json()
-            service_descriptor, method = self.get_descriptor_and_method(data["method"])
-            args = self.deserialize_args(data["args"], service_descriptor.type, method)
+    async def invoke_msgpack(self, http_request: HttpRequest):
+        data = msgpack.unpackb(await http_request.body(), raw=False)
+        service_descriptor, method = self.get_descriptor_and_method(data["method"])
+        args = self.deserialize_args(data["args"], service_descriptor.type, method)
 
-        elif "application/x-protobuf" in content_type:
-            content = "protobuf"
-            service_descriptor, method = self.get_descriptor_and_method(http_request.headers.get("x-rpc-method") )
-            self.protobuf_manager.check(service_descriptor.type)
-            data = await http_request.body()
+        try:
+            response = Response(result=await self.dispatch(service_descriptor, method, args), exception=None).model_dump()
+        except Exception as e:
+            response = Response(result=None, exception=str(e)).model_dump()
 
-            request_name = ProtobufManager.get_message_name(service_descriptor.type, f"{method.__name__}Request")
+        return HttpResponse(
+            content=msgpack.packb(response, use_bin_type=True),
+            media_type="application/msgpack"
+        )
 
-            request = self.protobuf_manager.get_message_type(request_name)()
-            request.ParseFromString(data)
+    async def invoke_protobuf(self, http_request: HttpRequest):
+        service_descriptor, method = self.get_descriptor_and_method(http_request.headers.get("x-rpc-method"))
 
-            args = self.protobuf_manager.create_deserializer(request.DESCRIPTOR, method).deserialize(request)
+        data = await http_request.body()
 
-        else:
-            return HttpResponse(
-                content="Unsupported Content-Type",
-                status_code=415,
-                media_type="text/plain"
-            )
+        # create message
 
-        request = data
+        request =  self.protobuf_manager.get_request_message(service_descriptor.type, method)()
+        request.ParseFromString(data)
 
-        if content == "json":
-            try:
-                result = await self.dispatch(service_descriptor, method, args)
+        # and parse
 
-                return Response(result=result, exception=None).model_dump()
-            except Exception as e:
-                return Response(result=None, exception=str(e)).model_dump()
+        args = self.protobuf_manager.create_deserializer(request.DESCRIPTOR, method).deserialize(request)
 
-        elif content == "protobuf":
-            response_name = ProtobufManager.get_message_name(service_descriptor.type, f"{method.__name__}Response")
-            response_type = self.protobuf_manager.get_message_type(response_name)
+        response_type =  self.protobuf_manager.get_response_message(service_descriptor.type,method)
+        result_serializer = self.protobuf_manager.create_result_serializer(response_type, method)
+        try:
+            result = await self.dispatch(service_descriptor, method, args)
 
-            result_serializer = self.protobuf_manager.create_result_serializer(response_type, method)
+            result_message = result_serializer.serialize_result(result, None)
 
-            try:
-                result = await self.dispatch(service_descriptor, method, args)
+            return HttpResponse(
+                content=result_message.SerializeToString(),
+                media_type="application/x-protobuf"
+            )
+
+        except Exception as e:
+            result_message = result_serializer.serialize_result(None, str(e))
+
+            return HttpResponse(
+                content=result_message.SerializeToString(),
+                media_type="application/x-protobuf"
+            )
 
-                result_message = result_serializer.serialize_result(result, None)
+    async def invoke(self, http_request: HttpRequest):
+        content_type = http_request.headers.get("content-type", "")
 
-                return HttpResponse(
-                    content=result_message.SerializeToString(),
-                    media_type="application/x-protobuf"
-                )
+        if content_type == "application/x-protobuf":
+            return await self.invoke_protobuf(http_request)
 
-            except Exception as e:
-                result_message = result_serializer.serialize_result(None, str(e))
+        elif content_type == "application/msgpack":
+            return await self.invoke_msgpack(http_request)
 
-                return HttpResponse(
-                    content=result_message.SerializeToString(),
-                    media_type="application/x-protobuf"
-                )
+        elif content_type == "application/json":
+            return await self.invoke_json(http_request)
 
         else:
-            try:
-                response = Response(result=await self.dispatch(service_descriptor, method, args), exception=None).model_dump()
-            except Exception as e:
-                response = Response(result=None, exception=str(e)).model_dump()
-
             return HttpResponse(
-                content=msgpack.packb(response, use_bin_type=True),
-                media_type="application/msgpack"
+                content="Unsupported Content-Type",
+                status_code=415,
+                media_type="text/plain"
             )
 
     async def dispatch(self, service_descriptor: ServiceDescriptor, method: Callable, args: list[Any]) :
-        ServiceManager.logger.debug("dispatch request %s.%s", service_descriptor, method.__name__)
+        #ServiceManager.logger.debug("dispatch request %s.%s", service_descriptor, method.__name__)
 
         if inspect.iscoroutinefunction(method):
             return await method(*args)
@@ -454,8 +447,8 @@ class FastAPIServer(Server):
 
     # override
 
-    def route(self, url: str, callable: Callable):
-        self.router.get(url)(callable)
+    def add_route(self, path: str, endpoint: Callable, methods: list[str], response_class: typing.Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse)):
+        self.router.add_api_route(path=path, endpoint=endpoint, methods=methods, response_class=response_class)
 
     def route_health(self, url: str, callable: Callable):
         async def get_health_response():

aspyx_service/service.py

@@ -7,12 +7,17 @@ import re
 import socket
 import logging
 import threading
+import typing
 from abc import abstractmethod, ABC
 from dataclasses import dataclass
 from enum import Enum, auto
 
 from typing import Type, TypeVar, Generic, Callable, Optional, cast
 
+from fastapi.datastructures import DefaultPlaceholder, Default
+from httpx import Response
+from starlette.responses import JSONResponse, PlainTextResponse
+
 from aspyx.di import injectable, Environment, Providers, ClassInstanceProvider, inject_environment, order, \
     Lifecycle, LifecycleCallable, InstanceProvider
 from aspyx.di.aop.aop import ClassAspectTarget
@@ -42,7 +47,7 @@ class ComponentStatus(Enum):
 
 class Server(ABC):
     """
-    A server is a central entity that boots a main module and initializes the ServiceManager.
+    A server is a central class that boots a main module and initializes the ServiceManager.
     It also is the place where http servers get initialized.
     """
     port = 0
@@ -51,6 +56,7 @@ class Server(ABC):
 
     def __init__(self):
         self.environment : Optional[Environment] = None
+        self.instance = self
 
     # public
 
@@ -58,7 +64,7 @@ class Server(ABC):
         return self.environment.get(type)
 
     @abstractmethod
-    def route(self, url : str, callable: Callable):
+    def add_route(self, path : str, endpoint : Callable, methods : list[str], response_class : typing.Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse)):
         pass
 
     @abstractmethod
@@ -573,7 +579,7 @@ class ChannelFactory:
     # constructor
 
     def __init__(self):
-        self.environment = None
+        self.environment : Optional[Environment] = None
 
     # lifecycle hooks
 
@@ -583,6 +589,12 @@ class ChannelFactory:
 
     # public
 
+    def prepare_channel(self, server: Server, channel: str, component_descriptor: ComponentDescriptor):
+        type = self.factories[channel]
+
+        if getattr(type, "prepare", None) is not None:
+            getattr(type, "prepare", None)(server, component_descriptor)
+
     def make(self, name: str, descriptor: ComponentDescriptor, address: ChannelInstances) -> Channel:
         ServiceManager.logger.info("create channel %s: %s", name, self.factories.get(name).__name__)
 
@@ -665,9 +677,9 @@ class ServiceManager:
 
     # constructor
 
-    def __init__(self, component_registry: ComponentRegistry, channel_manager: ChannelFactory):
+    def __init__(self, component_registry: ComponentRegistry, channel_factory: ChannelFactory):
         self.component_registry = component_registry
-        self.channel_manager = channel_manager
+        self.channel_factory = channel_factory
         self.environment : Optional[Environment] = None
         self.preferred_channel = ""
 
@@ -691,7 +703,7 @@ class ServiceManager:
     def get_instance(self, type: Type[T]) -> T:
         instance = self.instances.get(type)
         if instance is None:
-            ServiceManager.logger.info("create implementation %s", type.__name__)
+            ServiceManager.logger.debug("create implementation %s", type.__name__)
 
             instance = self.environment.get(type)
             self.instances[type] = instance
@@ -700,9 +712,16 @@ class ServiceManager:
 
     # lifecycle
 
+
     def startup(self, server: Server) -> None:
         self.logger.info("startup on port %s", server.port)
 
+        # add some introspection endpoints
+
+        server.add_route(path="/report", endpoint=lambda: self.report(), methods=["GET"], response_class=PlainTextResponse)
+
+        # boot components
+
         for descriptor in self.descriptors.values():
             if descriptor.is_component():
                 # register local address
@@ -725,8 +744,6 @@ class ServiceManager:
 
                     self.component_registry.register(descriptor.get_component_descriptor(), [ChannelAddress("local", "")])
 
-                    #health_name = next((decorator.args[0] for decorator in Decorators.get(descriptor.type) if decorator.decorator is health), None)
-
                     # startup
 
                     instance.startup()
@@ -738,9 +755,10 @@ class ServiceManager:
 
                     # register addresses
 
-                    self.component_registry.register(descriptor.get_component_descriptor(), descriptor.addresses)
+                    for address in descriptor.addresses:
+                        self.channel_factory.prepare_channel(server, address.channel, descriptor.get_component_descriptor())
 
-        print(self.report())
+                    self.component_registry.register(descriptor.get_component_descriptor(), descriptor.addresses)
 
     def shutdown(self):
         self.logger.info("shutdown")
@@ -823,7 +841,7 @@ class ServiceManager:
                 if channel_instance is None:
                     # create channel
 
-                    channel_instance = self.channel_manager.make(address.channel, component_descriptor, address)
+                    channel_instance = self.channel_factory.make(address.channel, component_descriptor, address)
 
                     # cache
 

{aspyx_service-0.11.0.dist-info → aspyx_service-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.11.0
+Version: 0.11.1
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -114,9 +114,6 @@ After booting the DI infrastructure with a main module we could already call a s
 ```python
 @module(imports=[ServiceModule])
 class Module:
-    def __init__(self):
-        pass
-
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
         return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=8500))  # a consul based registry!
@@ -137,11 +134,6 @@ 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]:
@@ -149,9 +141,6 @@ class TestComponentImpl(AbstractComponent, TestComponent):
 
 @implementation()
 class TestServiceImpl(TestService):
-    def __init__(self):
-        pass
-
     def hello(self, message: str) -> str:
         return f"hello {message}"
 ```
@@ -263,8 +252,7 @@ Service implementations implement the corresponding interface and are decorated
 ```python
 @implementation()
 class TestServiceImpl(TestService):
-    def __init__(self):
-        pass
+    pass
 ```
 
 The constructor is required since the instances are managed by the DI framework.
@@ -274,11 +262,6 @@ Component implementations derive from the interface and the abstract base class
 ```python
 @implementation()
 class TestComponentImpl(AbstractComponent, TestComponent):
-    # constructor
-
-    def __init__(self):
-        super().__init__()
-
     # implement Component
 
     def get_addresses(self, port: int) -> list[ChannelAddress]:
@@ -313,7 +296,9 @@ For this purpose injectable classes can be decorated with `@health_checks()` tha
 @injectable()
 class Checks:
     def __init__(self):
-        pass
+        pass #  normally, we would inject stuff here
+    
+    # checks
 
     @health_check(fail_if_slower_than=1)
     def check_performance(self, result: HealthCheckManager.Result):
@@ -382,6 +367,8 @@ Several channels are implemented:
    channel that posts generic `Request` objects via a `invoke` POST-call
 - `dispatch-msgpack`
    channel that posts generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
+- `dispatch-protobuf`
+   channel that posts parameters via a `invoke` POST-call after packing the arguments with protobuf
 - `rest`
   channel that executes regular rest-calls as defined by a couple of decorators.
 
@@ -401,14 +388,6 @@ To customize the behavior, an `around` advice can be implemented easily:
 ```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])
@@ -426,6 +405,7 @@ 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
+- dispatching protobuf
 
 The biggest advantage of the dispatching flavors is, that you don't have to worry about the additional decorators!
 
@@ -456,6 +436,11 @@ Additional annotations are
 - `Body` the post body
 - `QueryParam`marked for query params
 
+You can skip the annotations, assuming the following heuristic:
+
+- if no body is marked it will pick the first parameter which is a dataclass or a pydantic model
+- all parameters which are not in the path or equal to the body are assumed to be query params.
+
 ### Intercepting calls
 
 The client side HTTP calling is done with `httpx` instances of type `Httpx.Client` or `Httpx.AsyncClient`.
@@ -501,7 +486,7 @@ The required - `FastAPI` - infrastructure to expose those services requires:
 - and a final `boot` call with the root module, which will return an `Environment`
 
 ```python
-fast_api = FastAPI() # so you can run it with uvivorn from command-line
+fast_api = FastAPI() # so you can run it with uvicorn from command-line
 
 @module(imports=[ServiceModule])
 class Module:
@@ -513,7 +498,7 @@ class Module:
         return FastAPIServer(fastapi, service_manager, component_registry)
     
 
-environment = FastAPIServer.boot(Moudle, host="0.0.0.0", port=8000)
+environment = FastAPIServer.boot(Module, host="0.0.0.0", port=8000)
 ```
 
 This setup will also expose all service interfaces decorated with the corresponding http decorators!
@@ -560,6 +545,10 @@ class FancyChannel(Channel):
 
 - first release version
 
+**0.11.0**
+
+- added protobuf support
+
 
 
 

aspyx_service-0.11.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+aspyx_service/__init__.py,sha256=Mzt6pBhME_qDij2timEZT0emTTXRues_xXu3muhk3Jc,2642
+aspyx_service/authorization.py,sha256=0B1xb0WrRaj2rcGTHVUhh6i8aA0sy7BmpYA18xI9LQA,3833
+aspyx_service/channels.py,sha256=ujJnyWijNNNsl_kJu39bFV2MDq8OjBGOs7XXDWdpx9w,15314
+aspyx_service/healthcheck.py,sha256=XiQx1T0DP0kcCyK_sYBuE-JHs5N285HotLVycFCgzBU,5612
+aspyx_service/protobuf.py,sha256=w2wZymTSObGhgevIRZJ9kRxiEel8f6BycMPQiTYNMzI,39595
+aspyx_service/registries.py,sha256=bnTjKb40fbZXA52E2lDSEzCWI5_NBKZzQjc8ffufB5g,8039
+aspyx_service/restchannel.py,sha256=aCpNCvv1eIRa9IJW8Os4bQQErZKrEeyID65QhnD9QJw,9134
+aspyx_service/server.py,sha256=yI_croAT77PUh2_z1-EGklgzxjMvuUtHomckN3piaBo,15794
+aspyx_service/service.py,sha256=gOX5rbOOLJ-cSIvxa_5lqo1DzcPmDoJCBbMP-ZYKYxs,27972
+aspyx_service/session.py,sha256=HjGpnmwdislc8Ur6pQbSMi2K-lvTsb9_XyO80zupiF8,3713
+aspyx_service-0.11.1.dist-info/METADATA,sha256=nYCeGXZYBRnaEIFYNJYgIY_b5p0qEIOHZI30hwEUwr4,18127
+aspyx_service-0.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aspyx_service-0.11.1.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
+aspyx_service-0.11.1.dist-info/RECORD,,

aspyx_service-0.11.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-aspyx_service/__init__.py,sha256=Mzt6pBhME_qDij2timEZT0emTTXRues_xXu3muhk3Jc,2642
-aspyx_service/authorization.py,sha256=0B1xb0WrRaj2rcGTHVUhh6i8aA0sy7BmpYA18xI9LQA,3833
-aspyx_service/channels.py,sha256=6R9WeC8JO-TI2FPtWBm7ad-jivn-gmkHoB7z6xosw6A,17423
-aspyx_service/healthcheck.py,sha256=XiQx1T0DP0kcCyK_sYBuE-JHs5N285HotLVycFCgzBU,5612
-aspyx_service/protobuf.py,sha256=OTOPRxpzPZEK0lX2BIH3R-FNnxiBtsWvypuyzMla5bU,39010
-aspyx_service/registries.py,sha256=bnTjKb40fbZXA52E2lDSEzCWI5_NBKZzQjc8ffufB5g,8039
-aspyx_service/restchannel.py,sha256=aCpNCvv1eIRa9IJW8Os4bQQErZKrEeyID65QhnD9QJw,9134
-aspyx_service/server.py,sha256=dl3UWawQRPNy7h9WzHQge3dF8nG_3oYWBVgjfN-iqQg,15891
-aspyx_service/service.py,sha256=0sFBpjRxEtMjRhwI1f51qsUCcTzbqoMx7gA3gZNge7A,27159
-aspyx_service/session.py,sha256=HjGpnmwdislc8Ur6pQbSMi2K-lvTsb9_XyO80zupiF8,3713
-aspyx_service-0.11.0.dist-info/METADATA,sha256=ff-Pa-1neQhtVGBX4ByuVLQ8ujH54AjND7unm1H8F2U,17978
-aspyx_service-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aspyx_service-0.11.0.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx_service-0.11.0.dist-info/RECORD,,