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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.2
+Version: 0.10.4
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -26,7 +26,8 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.5.1
+Requires-Dist: aspyx>=1.5.3
+Requires-Dist: cachetools~=5.5.2
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
@@ -60,6 +61,8 @@ Description-Content-Type: text/markdown
   - [Rest Calls](#rest-calls)
   - [Intercepting calls](#intercepting-calls)
 - [FastAPI server](#fastapi-server)
+- [Session](#session)
+- [Authorization](#authorization)
 - [Implementing Channels](#implementing-channels)
 - [Version History](#version-history)
 
@@ -70,19 +73,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.
@@ -111,7 +118,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)
@@ -162,10 +169,24 @@ environment = server.boot(Module)
 Of course, service can also be called locally. In case of multiple possible channels, a keyword argument is used to 
 determine a specific channel. As a local channel has the name "local", the appropriate call is:
 
+**Example**:
+
 ```python
  service = service_manager.get_service(TestService, preferred_channel="local")
 ```
 
+The default can be set globally with the method `set_preferred_channel(channel: str)`
+
+Injecting services is also possible via the decorator `@inject_service(preferred_channel=""")`
+
+**Example**:
+
+```python
+@inject_service()
+def set_service(self, service: TestService)
+   self.service = service
+```
+
 ## Features
 
 The library offers:
@@ -348,12 +369,14 @@ Channels implement the possible transport layer protocols. In the sense of a dyn
 Several channels are implemented:
 
 - `dispatch-json`
-   channel that dispatches generic `Request` objects via a `invoke` POST-call
+   channel that posts generic `Request` objects via a `invoke` POST-call
 - `dispatch-msgpack`
-   channel that dispatches generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
+   channel that posts generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
 - `rest`
   channel that executes regular rest-calls as defined by a couple of decorators.
 
+The `dispatch`channels have the big advantage, that you don`t have to deal with additional http decorators!
+
 All channels react on changed URLs as provided by the component registry.
 
 A so called `URLSelector` is used internally to provide URLs for every single call. Two subclasses exist that offer a different logic
@@ -361,7 +384,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**:
  
@@ -478,6 +501,14 @@ class Module():
 This setup will also expose all service interfaces decorated with the corresponding http decorators!
 No need to add any FastAPI decorators, since the mapping is already done internally! 
 
+## Session
+
+TODO
+
+## Authorization
+
+TODO
+
 ## Implementing Channels
 
 To implement a new channel, you only need to derive from one of the possible base classes ( `Channel` or `HTTPXChannel` that already has a `httpx` client)

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

@@ -24,6 +24,8 @@
   - [Rest Calls](#rest-calls)
   - [Intercepting calls](#intercepting-calls)
 - [FastAPI server](#fastapi-server)
+- [Session](#session)
+- [Authorization](#authorization)
 - [Implementing Channels](#implementing-channels)
 - [Version History](#version-history)
 
@@ -34,19 +36,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.
@@ -75,7 +81,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)
@@ -126,10 +132,24 @@ environment = server.boot(Module)
 Of course, service can also be called locally. In case of multiple possible channels, a keyword argument is used to 
 determine a specific channel. As a local channel has the name "local", the appropriate call is:
 
+**Example**:
+
 ```python
  service = service_manager.get_service(TestService, preferred_channel="local")
 ```
 
+The default can be set globally with the method `set_preferred_channel(channel: str)`
+
+Injecting services is also possible via the decorator `@inject_service(preferred_channel=""")`
+
+**Example**:
+
+```python
+@inject_service()
+def set_service(self, service: TestService)
+   self.service = service
+```
+
 ## Features
 
 The library offers:
@@ -312,12 +332,14 @@ Channels implement the possible transport layer protocols. In the sense of a dyn
 Several channels are implemented:
 
 - `dispatch-json`
-   channel that dispatches generic `Request` objects via a `invoke` POST-call
+   channel that posts generic `Request` objects via a `invoke` POST-call
 - `dispatch-msgpack`
-   channel that dispatches generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
+   channel that posts generic `Request` objects via a `invoke` POST-call after packing the json with msgpack
 - `rest`
   channel that executes regular rest-calls as defined by a couple of decorators.
 
+The `dispatch`channels have the big advantage, that you don`t have to deal with additional http decorators!
+
 All channels react on changed URLs as provided by the component registry.
 
 A so called `URLSelector` is used internally to provide URLs for every single call. Two subclasses exist that offer a different logic
@@ -325,7 +347,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**:
  
@@ -442,6 +464,14 @@ class Module():
 This setup will also expose all service interfaces decorated with the corresponding http decorators!
 No need to add any FastAPI decorators, since the mapping is already done internally! 
 
+## Session
+
+TODO
+
+## Authorization
+
+TODO
+
 ## Implementing Channels
 
 To implement a new channel, you only need to derive from one of the possible base classes ( `Channel` or `HTTPXChannel` that already has a `httpx` client)

aspyx_service-0.10.4/performance-test/client.py

@@ -0,0 +1,154 @@
+"""
+Tests
+"""
+
+from abc import abstractmethod
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from aspyx.di import module
+
+from aspyx_service import ServiceModule, delete, post, put, get, rest, Body
+from aspyx_service.service import  component, Component, Service, service
+
+class Pydantic(BaseModel):
+    i: int
+    f: float
+    b: bool
+    s: str
+
+    str0 : str
+    str1: str
+    str2: str
+    str3: str
+    str4: str
+    str5: str
+    str6: str
+    str7: str
+    str8: str
+    str9: str
+
+
+@dataclass
+class Data:
+    i: int
+    f: float
+    b: bool
+    s: str
+
+    str0: str
+    str1: str
+    str2: str
+    str3: str
+    str4: str
+    str5: str
+    str6: str
+    str7: str
+    str8: str
+    str9: str
+
+class PydanticAndData(BaseModel):
+    p: Pydantic
+
+@dataclass
+class DataAndPydantic:
+    d: Data
+
+# service
+
+@service(name="test-service", description="cool")
+class TestService(Service):
+    @abstractmethod
+    def hello(self, message: str) -> str:
+        pass
+
+    @abstractmethod
+    def throw(self, message: str) -> str:
+        pass
+
+    @abstractmethod
+    def data(self, data: Data) -> Data:
+        pass
+
+    @abstractmethod
+    def pydantic(self, data: Pydantic) -> Pydantic:
+        pass
+
+@service(name="test-async-service", description="cool")
+class TestAsyncService(Service):
+    @abstractmethod
+    async def hello(self, message: str) -> str:
+        pass
+
+    @abstractmethod
+    async def data(self, data: Data) -> Data:
+        pass
+
+    @abstractmethod
+    async def pydantic(self, data: Pydantic) -> Pydantic:
+        pass
+
+@service(name="test-rest-service", description="cool")
+@rest("/api")
+class TestRestService(Service):
+    @abstractmethod
+    @get("/hello/{message}")
+    def get(self, message: str) -> str:
+        pass
+
+    @put("/hello/{message}")
+    def put(self, message: str) -> str:
+        pass
+
+    @post("/hello/{message}")
+    def post_pydantic(self, message: str, data: Body(Pydantic)) -> Pydantic:
+        pass
+
+    @post("/hello/{message}")
+    def post_data(self, message: str, data: Body(Data)) -> Data:
+        pass
+
+    @delete("/hello/{message}")
+    def delete(self, message: str) -> str:
+        pass
+
+@service(name="test-async-rest-service", description="cool")
+@rest("/async-api")
+class TestAsyncRestService(Service):
+    @abstractmethod
+    @get("/hello/{message}")
+    async def get(self, message: str) -> str:
+        pass
+
+    @put("/hello/{message}")
+    async def put(self, message: str) -> str:
+        pass
+
+    @post("/hello/{message}")
+    async def post_pydantic(self, message: str, data: Body(Pydantic)) -> Pydantic:
+        pass
+
+    @post("/hello/{message}")
+    async def post_data(self, message: str, data: Body(Data)) -> Data:
+        pass
+
+    @delete("/hello/{message}")
+    async def delete(self, message: str) -> str:
+        pass
+
+@component(services =[
+    TestService,
+    TestAsyncService,
+    TestRestService,
+    TestAsyncRestService
+])
+class TestComponent(Component): # pylint: disable=abstract-method
+    pass
+
+# module
+
+@module(imports=[ServiceModule])
+class ClientModule:
+    def __init__(self):
+        pass

aspyx_service-0.10.4/performance-test/main.py

@@ -0,0 +1,23 @@
+import logging
+import os
+
+from aspyx.util import Logger
+from aspyx_service import FastAPIServer
+from server import  ServerModule
+
+Logger.configure(default_level=logging.DEBUG, levels={
+    "httpx": logging.ERROR,
+    "aspyx.di": logging.ERROR,
+    "aspyx.di.aop": logging.ERROR,
+    "aspyx.service": logging.ERROR
+})
+
+PORT = int(os.getenv("FAST_API_PORT", 8000))
+
+FastAPIServer.boot(module=ServerModule, host="0.0.0.0", port=PORT, start = False)
+
+app = FastAPIServer.fast_api
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=PORT, reload=True, log_level="warning", access_log=False)

aspyx_service-0.10.4/performance-test/performance-test.py

@@ -0,0 +1,279 @@
+"""
+Tests
+"""
+import asyncio
+import threading
+import time
+import logging
+
+from typing import Callable, TypeVar, Type, Awaitable, Any, Dict, cast
+
+from consul import Consul
+
+from aspyx.di import module, Environment, create
+from aspyx.di.aop import advice, around, methods, Invocation
+from aspyx.util import Logger
+
+from aspyx_service import ConsulComponentRegistry
+from aspyx_service.service import ServiceManager, ComponentRegistry, Channel
+
+Logger.configure(default_level=logging.DEBUG, levels={
+    "httpx": logging.ERROR,
+    "aspyx.di": logging.ERROR,
+    "aspyx.di.aop": logging.ERROR,
+    "aspyx.service": logging.ERROR
+})
+
+from client import TestService, TestRestService, Pydantic, Data, TestAsyncRestService, TestAsyncService, ClientModule
+
+# main
+
+@advice
+class ChannelAdvice:
+    def __init__(self):
+        pass
+
+    @around(methods().named("customize").of_type(Channel))
+    def customize_channel(self, invocation: Invocation):
+        channel = cast(Channel, invocation.args[0])
+
+        channel.select_round_robin() # or select_first_url()
+
+        return invocation.proceed()
+
+@module(imports=[ClientModule])
+class TestModule:
+    def __init__(self):
+        pass
+
+    @create()
+    def create_registry(self) -> ComponentRegistry:
+        return ConsulComponentRegistry(port=8000, consul=Consul(host="localhost", port=8500))
+
+def boot() -> ServiceManager:
+    environment = Environment(TestModule)
+
+    service_manager = environment.get(ServiceManager)
+
+    return service_manager
+
+T = TypeVar("T")
+
+# main
+
+lorem_ipsum = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua"
+
+pydantic = Pydantic(i=1, f=1.0, b=True, s="s",
+                    str0=lorem_ipsum,
+                    str1=lorem_ipsum,
+                    str2=lorem_ipsum,
+                    str3=lorem_ipsum,
+                    str4=lorem_ipsum,
+                    str5=lorem_ipsum,
+                    str6=lorem_ipsum,
+                    str7=lorem_ipsum,
+                    str8=lorem_ipsum,
+                    str9=lorem_ipsum
+                    )
+data = Data(i=1, f=1.0, b=True, s="s",
+                    str0=lorem_ipsum,
+                    str1=lorem_ipsum,
+                    str2=lorem_ipsum,
+                    str3=lorem_ipsum,
+                    str4=lorem_ipsum,
+                    str5=lorem_ipsum,
+                    str6=lorem_ipsum,
+                    str7=lorem_ipsum,
+                    str8=lorem_ipsum,
+                    str9=lorem_ipsum
+            )
+
+def run_loops(name: str, loops: int, type: Type[T], instance: T,  callable: Callable[[T], None]):
+    start = time.perf_counter()
+    for _ in range(loops):
+        callable(instance)
+
+    end = time.perf_counter()
+    avg_ms = ((end - start) / loops) * 1000
+
+    print(f"run {name}, loops={loops}: avg={avg_ms:.3f} ms")
+
+async def run_async_loops(name: str, loops: int, type: Type[T], instance: T,  callable: Callable[[T], Awaitable[Any]]):
+    start = time.perf_counter()
+    for _ in range(loops):
+        await callable(instance)
+
+    end = time.perf_counter()
+    avg_ms = ((end - start) / loops) * 1000
+
+    print(f"run {name}, loops={loops}: avg={avg_ms:.3f} ms")
+
+def run_threaded_async_loops(name: str, loops: int, n_threads: int,  type: Type[T], instance: T,  callable: Callable[[T], Awaitable[Any]]):
+    threads = []
+
+    def worker(thread_id: int):
+        #print(f"worker {thread_id} running on thread {threading.current_thread().name}")
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        async def run():
+            for i in range(loops):
+                await callable(instance)
+
+        loop.run_until_complete(run())
+        loop.close()
+
+    start = time.perf_counter()
+
+    for t_id in range(0, n_threads):
+        thread = threading.Thread(target=worker, args=(t_id,))
+        threads.append(thread)
+        thread.start()
+
+    for thread in threads:
+        thread.join()
+
+    end = time.perf_counter()
+    took = (end - start) * 1000
+    avg_ms = ((end - start) / (n_threads * loops)) * 1000
+
+    print(f"{name} {loops} in {n_threads} threads: {took} ms, avg: {avg_ms}ms")
+
+def run_threaded_sync_loops(name: str, loops: int, n_threads: int,  type: Type[T], instance: T,  callable: Callable[[T], Any]):
+    threads = []
+
+    def worker(thread_id: int):
+        #print(f"worker {thread_id} running on thread {threading.current_thread().name}")
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        async def run():
+            for i in range(loops):
+                callable(instance)
+
+        loop.run_until_complete(run())
+        loop.close()
+
+    start = time.perf_counter()
+
+    for t_id in range(0, n_threads):
+        thread = threading.Thread(target=worker, args=(t_id,))
+        threads.append(thread)
+        thread.start()
+
+    for thread in threads:
+        thread.join()
+
+    end = time.perf_counter()
+    took = (end - start) * 1000
+    avg_ms = ((end - start) / (n_threads * loops)) * 1000
+
+    print(f"{name} {loops} in {n_threads} threads: {took} ms, avg: {avg_ms}ms")
+
+manager = boot()
+
+async def main():
+    print("start tests...")
+
+    # get service manager
+
+    loops = 1000
+
+    # tests
+
+    run_loops("rest", loops, TestRestService, manager.get_service(TestRestService, preferred_channel="rest"), lambda service: service.get("world"))
+    run_loops("json", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-json"), lambda service: service.hello("world"))
+    run_loops("msgpack", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-msgpack"), lambda service: service.hello("world"))
+
+    # pydantic
+
+    run_loops("rest & pydantic", loops, TestRestService, manager.get_service(TestRestService, preferred_channel="rest"), lambda service: service.post_pydantic("hello", pydantic))
+    run_loops("json & pydantic", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-json"), lambda service: service.pydantic(pydantic))
+    run_loops("msgpack & pydantic", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-msgpack"), lambda service: service.pydantic(pydantic))
+
+    # data class
+
+    run_loops("rest & data", loops, TestRestService, manager.get_service(TestRestService, preferred_channel="rest"),
+              lambda service: service.post_data("hello", data))
+    run_loops("json & data", loops, TestService,
+              manager.get_service(TestService, preferred_channel="dispatch-json"),
+              lambda service: service.data(data))
+    run_loops("msgpack & data", loops, TestService,
+              manager.get_service(TestService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.data(data))
+
+    # async
+
+    await run_async_loops("async rest", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
+              lambda service: service.get("world"))
+    await run_async_loops("async json", loops, TestAsyncService, manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+              lambda service: service.hello("world"))
+    await run_async_loops("async msgpack", loops, TestAsyncService, manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.hello("world"))
+
+    # pydantic
+
+    await run_async_loops("async rest & pydantic", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
+              lambda service: service.post_pydantic("hello", pydantic))
+    await run_async_loops("async json & pydantic", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+              lambda service: service.pydantic(pydantic))
+    await run_async_loops("async msgpack & pydantic", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.pydantic(pydantic))
+
+    # data class
+
+    # pydantic
+
+    await run_async_loops("async rest & data", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
+              lambda service: service.post_data("hello", data))
+    await run_async_loops("async json & data", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+              lambda service: service.data(data))
+    await run_async_loops("async msgpack & data", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.data(data))
+
+    # a real thread test
+
+    # sync
+
+    run_threaded_sync_loops("threaded sync json, 1 thread", loops, 1, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 2 thread", loops, 2, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 4 thread", loops, 4, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 8 thread", loops, 8, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 16 thread", loops, 16, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+
+    # async
+
+    run_threaded_async_loops("threaded async json, 1 thread", loops, 1, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world") )
+    run_threaded_async_loops("threaded async json, 2 thread", loops, 2, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_async_loops("threaded async json, 4 thread", loops, 4, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_async_loops("threaded async json, 8 thread", loops, 8, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_async_loops("threaded async json, 16 thread", loops, 16, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+
+if __name__ == "__main__":
+    asyncio.run(main())