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

aspyx_service/restchannel.py

@@ -9,6 +9,7 @@ from typing import get_type_hints, TypeVar, Annotated, Callable, get_origin, get
 from pydantic import BaseModel
 
 from aspyx.reflection import DynamicProxy, Decorators
+from aspyx.util import get_serializer
 
 from .channels import HTTPXChannel
 from .service import channel, ServiceCommunicationException
@@ -130,9 +131,26 @@ class RestChannel(HTTPXChannel):
     # local class
 
     class Call:
+        # slots
+
+        __slots__ = [
+            "type",
+            "url_template",
+            "path_param_names",
+            "body_param_name",
+            "query_param_names",
+            "return_type",
+            "signature",
+            "body_serializer"
+        ]
+
+        # constructor
+
         def __init__(self, type: Type, method : Callable):
             self.signature = inspect.signature(method)
 
+            type_hints = get_type_hints(method)
+
             param_names = list(self.signature.parameters.keys())
             param_names.remove("self")
 
@@ -171,6 +189,7 @@ class RestChannel(HTTPXChannel):
 
                     if BodyMarker in metadata:
                         self.body_param_name = param_name
+                        self.body_serializer = get_serializer(type_hints[param_name])
                         param_names.remove(param_name)
                     elif QueryParamMarker in metadata:
                         self.query_param_names.add(param_name)
@@ -197,6 +216,7 @@ class RestChannel(HTTPXChannel):
                                     or is_dataclass(typ)
                             ):
                                 self.body_param_name = name
+                                self.body_serializer = get_serializer(type_hints[name])
                                 param_names.remove(name)
                                 break
 
@@ -207,7 +227,7 @@ class RestChannel(HTTPXChannel):
 
             # return type
 
-            self.return_type = get_type_hints(method)['return']
+            self.return_type = type_hints['return']
 
     # constructor
 
@@ -241,7 +261,7 @@ class RestChannel(HTTPXChannel):
         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))
+            body = call.body_serializer(arguments.get(call.body_param_name))#self.to_dict(arguments.get(call.body_param_name))
 
         # call
 
@@ -273,7 +293,7 @@ class RestChannel(HTTPXChannel):
         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))
+            body = call.body_serializer(arguments.get(call.body_param_name))#self.to_dict(arguments.get(call.body_param_name))
 
         # call
 

aspyx_service/server.py

@@ -14,16 +14,17 @@ 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, injectable, on_init, inject_environment, on_destroy
+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 .service import ComponentRegistry
+from .protobuf import ProtobufManager
+from .service import ComponentRegistry, ServiceDescriptor
 from .healthcheck import HealthCheckManager
 
 from .service import Server, ServiceManager
@@ -172,10 +173,11 @@ class FastAPIServer(Server):
 
     # constructor
 
-    def __init__(self, fast_api: FastAPI, service_manager: ServiceManager, component_registry: ComponentRegistry):
+    def __init__(self, fast_api: FastAPI, service_manager: ServiceManager, component_registry: ComponentRegistry, protobuf_manager: ProtobufManager):
         super().__init__()
 
         self.environment : Optional[Environment] = None
+        self.protobuf_manager = protobuf_manager
         self.service_manager = service_manager
         self.component_registry = component_registry
 
@@ -190,7 +192,7 @@ class FastAPIServer(Server):
 
         # cache
 
-        self.deserializers: dict[str, list[Callable]] = {}
+        self.deserializers = CopyOnWriteCache[str, list[Callable]]()
 
         # that's the overall dispatcher
 
@@ -213,6 +215,7 @@ class FastAPIServer(Server):
         self.add_routes()
         self.fast_api.include_router(self.router)
 
+        # TODO: trace routes
         #for route in self.fast_api.routes:
         #    print(f"{route.name}: {route.path} [{route.methods}]")
 
@@ -325,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):
@@ -344,68 +345,110 @@ class FastAPIServer(Server):
 
         return args
 
-    async def invoke(self, http_request: HttpRequest):
-        content_type = http_request.headers.get("content-type", "")
+    def get_descriptor_and_method(self, method_name: str) -> typing.Tuple[ServiceDescriptor, Callable]:
+        parts = method_name.split(":")
 
-        content = "json"
-        if "application/msgpack" in content_type:
-            content = "msgpack"
-            raw_data = await http_request.body()
-            data = msgpack.unpackb(raw_data, raw=False)
-        elif "application/json" in content_type:
-            data = await http_request.json()
-        else:
-            return HttpResponse(
-                content="Unsupported Content-Type",
-                status_code=415,
-                media_type="text/plain"
-            )
+        # component = parts[0]
+        service_name = parts[1]
+        method_name = parts[2]
 
-        request = data
+        service_descriptor = typing.cast(ServiceDescriptor, ServiceManager.descriptors_by_name[service_name])
+        service = self.service_manager.get_service(service_descriptor.type, preferred_channel="local")
 
-        if content == "json":
-            return await self.dispatch(http_request, request)
-        else:
-            return HttpResponse(
-                content=msgpack.packb(await self.dispatch(http_request, request), use_bin_type=True),
-                media_type="application/msgpack"
-            )
+        return service_descriptor, getattr(service, method_name)
 
-    async def dispatch(self, http_request: HttpRequest, request: dict) :
-        ServiceManager.logger.debug("dispatch request %s", request["method"])
+    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)
 
-        # <comp>:<service>:<method>
+        try:
+            result = await self.dispatch(service_descriptor, method, args)
 
-        parts = request["method"].split(":")
+            return Response(result=result, exception=None).model_dump()
+        except Exception as e:
+            return Response(result=None, exception=str(e)).model_dump()
 
-        #component = parts[0]
-        service_name = parts[1]
-        method_name = parts[2]
+    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)
 
-        service_descriptor = ServiceManager.descriptors_by_name[service_name]
-        service = self.service_manager.get_service(service_descriptor.type, preferred_channel="local")
+        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"
+        )
+
+    async def invoke_protobuf(self, http_request: HttpRequest):
+        service_descriptor, method = self.get_descriptor_and_method(http_request.headers.get("x-rpc-method"))
 
-        method = getattr(service, method_name)
+        data = await http_request.body()
 
-        args = self.deserialize_args(request["args"], service_descriptor.type, method)
+        # create message
+
+        request =  self.protobuf_manager.get_request_message(service_descriptor.type, method)()
+        request.ParseFromString(data)
+
+        # and parse
+
+        args = self.protobuf_manager.create_deserializer(request.DESCRIPTOR, method).deserialize(request)
+
+        response_type =  self.protobuf_manager.get_response_message(service_descriptor.type,method)
+        result_serializer = self.protobuf_manager.create_result_serializer(response_type, method)
         try:
-            if inspect.iscoroutinefunction(method):
-                result = await method(*args)
-            else:
-                result = method(*args)
+            result = await self.dispatch(service_descriptor, method, args)
 
-            return Response(result=result, exception=None).model_dump()
+            result_message = result_serializer.serialize_result(result, None)
 
-        except HTTPException as e:
-            raise
+            return HttpResponse(
+                content=result_message.SerializeToString(),
+                media_type="application/x-protobuf"
+            )
 
         except Exception as e:
-            return Response(result=None, exception=str(e)).model_dump()
+            result_message = result_serializer.serialize_result(None, str(e))
+
+            return HttpResponse(
+                content=result_message.SerializeToString(),
+                media_type="application/x-protobuf"
+            )
+
+    async def invoke(self, http_request: HttpRequest):
+        content_type = http_request.headers.get("content-type", "")
+
+        if content_type == "application/x-protobuf":
+            return await self.invoke_protobuf(http_request)
+
+        elif content_type == "application/msgpack":
+            return await self.invoke_msgpack(http_request)
+
+        elif content_type == "application/json":
+            return await self.invoke_json(http_request)
+
+        else:
+            return HttpResponse(
+                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__)
+
+        if inspect.iscoroutinefunction(method):
+            return await method(*args)
+        else:
+            return method(*args)
 
     # 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,17 +7,23 @@ 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
 from aspyx.reflection import Decorators, DynamicProxy, DecoratorDescriptor, TypeDescriptor
 from aspyx.util import StringBuilder
+
 from .healthcheck import HealthCheckManager, HealthStatus
 
 T = TypeVar("T")
@@ -41,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
@@ -50,6 +56,7 @@ class Server(ABC):
 
     def __init__(self):
         self.environment : Optional[Environment] = None
+        self.instance = self
 
     # public
 
@@ -57,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
@@ -557,7 +564,7 @@ class ComponentRegistry:
 
 
 @injectable()
-class ChannelManager:
+class ChannelFactory:
     """
     Internal factory for channels.
     """
@@ -567,12 +574,12 @@ class ChannelManager:
     def register_channel(cls, channel: str, type: Type):
         ServiceManager.logger.info("register channel %s", channel)
 
-        ChannelManager.factories[channel] = type
+        ChannelFactory.factories[channel] = type
 
     # constructor
 
     def __init__(self):
-        self.environment = None
+        self.environment : Optional[Environment] = None
 
     # lifecycle hooks
 
@@ -582,6 +589,12 @@ class ChannelManager:
 
     # 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__)
 
@@ -603,7 +616,7 @@ def channel(name: str):
 
         Providers.register(ClassInstanceProvider(cls, False, "request"))
 
-        ChannelManager.register_channel(name, cls)
+        ChannelFactory.register_channel(name, cls)
 
         return cls
 
@@ -649,20 +662,24 @@ class ServiceManager:
     def register_component(cls, component_type: Type, services: list[Type]):
         component_descriptor = ComponentDescriptor(component_type, services)
 
+        setattr(component_type, "__descriptor__", component_descriptor)
+
         cls.logger.info("register component %s", component_descriptor.name)
 
         ServiceManager.descriptors[component_type] = component_descriptor
         ServiceManager.descriptors_by_name[component_descriptor.name] = component_descriptor
 
         for component_service in component_descriptor.services:
+            setattr(component_service.type, "__descriptor__", component_service)
+
             ServiceManager.descriptors[component_service.type] = component_service
             ServiceManager.descriptors_by_name[component_service.name] = component_service
 
     # constructor
 
-    def __init__(self, component_registry: ComponentRegistry, channel_manager: ChannelManager):
+    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 = ""
 
@@ -686,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
@@ -695,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
@@ -720,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()
@@ -733,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")
@@ -818,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.10.7.dist-info → aspyx_service-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.7
+Version: 0.11.1
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -26,10 +26,11 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.6.0
+Requires-Dist: aspyx>=1.7.0
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
+Requires-Dist: protobuf~=5.29.4
 Requires-Dist: python-consul2~=0.1.5
 Requires-Dist: uvicorn[standard]
 Description-Content-Type: text/markdown
@@ -113,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!
@@ -136,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]:
@@ -148,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}"
 ```
@@ -262,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.
@@ -273,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]:
@@ -312,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):
@@ -381,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.
 
@@ -400,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])
@@ -425,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!
 
@@ -455,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`.
@@ -500,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:
@@ -512,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!
@@ -559,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.10.7.dist-info/RECORD

@@ -1,13 +0,0 @@
-aspyx_service/__init__.py,sha256=OWJoScdDVK1NTs9cIgImShgEdJb8TZHLBQjS11rA0Yo,2564
-aspyx_service/authorization.py,sha256=0B1xb0WrRaj2rcGTHVUhh6i8aA0sy7BmpYA18xI9LQA,3833
-aspyx_service/channels.py,sha256=u1afqUfcmVgLxXDXC2BYHH-dMozLcmVROuPRpypSwr8,16397
-aspyx_service/healthcheck.py,sha256=vjfY7s5kd5mRJynVpvAJ4BvVF7QY1xrvj94Y-m041LQ,5615
-aspyx_service/registries.py,sha256=bnTjKb40fbZXA52E2lDSEzCWI5_NBKZzQjc8ffufB5g,8039
-aspyx_service/restchannel.py,sha256=0Xb8grEE8Dyx3g3ENl78DDMKa2WGjIKIPgOrpw5p9ak,8470
-aspyx_service/server.py,sha256=75B1l__GknjwKX2jGIoR4YUTaaFBEVQ_qfHW2a3cy4U,13354
-aspyx_service/service.py,sha256=drETAZasbYJZisnmbhAqW0-mHghJ3IWyPaU-7etxvBI,27003
-aspyx_service/session.py,sha256=HjGpnmwdislc8Ur6pQbSMi2K-lvTsb9_XyO80zupiF8,3713
-aspyx_service-0.10.7.dist-info/METADATA,sha256=mZ2ZsGGqncY4y4pGpeaOy-cDIQu7OHwRWjW09T1jzwM,17946
-aspyx_service-0.10.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aspyx_service-0.10.7.dist-info/licenses/LICENSE,sha256=n4jfx_MNj7cBtPhhI7MCoB_K35cj1icP9yJ4Rh4vlvY,1070
-aspyx_service-0.10.7.dist-info/RECORD,,