aspyx-service 0.10.3__tar.gz → 0.10.5__tar.gz

{aspyx_service-0.10.3 → aspyx_service-0.10.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.3
+Version: 0.10.5
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.5.1
+Requires-Dist: aspyx>=1.6.0
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
@@ -60,6 +60,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)
 
@@ -107,18 +109,20 @@ class TestComponent(Component):
 After booting the DI infrastructure with a main module we could already call a service:
 
 **Example**:
+
 ```python
 @module(imports=[ServiceModule])
 class Module:
     def __init__(self):
         pass
-    
+
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
-        return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=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)
+service_manager = environment.read(ServiceManager)
 
 service = service_manager.get_service(TestService)
 
@@ -166,10 +170,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:
@@ -185,6 +203,14 @@ The library offers:
 As well as the DI and AOP core, all mechanisms are heavily optimized.
 A simple benchmark resulted in message roundtrips in significanlty under a ms per call.
 
+## Installation
+
+Just install from PyPI with 
+
+`pip install aspyx-service`
+
+The library is tested with all Python version >= 3.9
+
 Let's see some details
 
 ## Service and Component declaration 
@@ -352,12 +378,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
@@ -465,23 +493,39 @@ class ChannelAdvice:
 
 ## FastAPI server
 
-In order to expose components via HTTP, the corresponding infrastructure in form of a FastAPI server needs to be setup. 
+The required - `FastAPI` - infrastructure to expose those services requires:
 
+- a `FastAPI` instance
+- an injectable `FastAPIServer`
+- and a final `boot` call with the root module, which will return an `Environment`
 
 ```python
-@module()
-class Module():
+fast_api = FastAPI() # so you can run it with uvivorn from command-line
+
+@module(imports=[ServiceModule])
+class Module:
     def __init__(self):
         pass
+
+    @create()
+    def create_server(self,  service_manager: ServiceManager, component_registry: ComponentRegistry) -> FastAPIServer:
+        return FastAPIServer(fastapi, service_manager, component_registry)
     
- server = FastAPIServer(host="0.0.0.0", port=8000)
 
- environment = server.boot(Module) # will start the http server
+environment = FastAPIServer.boot(Moudle, host="0.0.0.0", port=8000)
 ```
 
 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.3 → aspyx_service-0.10.5}/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)
 
@@ -71,18 +73,20 @@ class TestComponent(Component):
 After booting the DI infrastructure with a main module we could already call a service:
 
 **Example**:
+
 ```python
 @module(imports=[ServiceModule])
 class Module:
     def __init__(self):
         pass
-    
+
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
-        return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=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)
+service_manager = environment.read(ServiceManager)
 
 service = service_manager.get_service(TestService)
 
@@ -130,10 +134,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:
@@ -149,6 +167,14 @@ The library offers:
 As well as the DI and AOP core, all mechanisms are heavily optimized.
 A simple benchmark resulted in message roundtrips in significanlty under a ms per call.
 
+## Installation
+
+Just install from PyPI with 
+
+`pip install aspyx-service`
+
+The library is tested with all Python version >= 3.9
+
 Let's see some details
 
 ## Service and Component declaration 
@@ -316,12 +342,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
@@ -429,23 +457,39 @@ class ChannelAdvice:
 
 ## FastAPI server
 
-In order to expose components via HTTP, the corresponding infrastructure in form of a FastAPI server needs to be setup. 
+The required - `FastAPI` - infrastructure to expose those services requires:
 
+- a `FastAPI` instance
+- an injectable `FastAPIServer`
+- and a final `boot` call with the root module, which will return an `Environment`
 
 ```python
-@module()
-class Module():
+fast_api = FastAPI() # so you can run it with uvivorn from command-line
+
+@module(imports=[ServiceModule])
+class Module:
     def __init__(self):
         pass
+
+    @create()
+    def create_server(self,  service_manager: ServiceManager, component_registry: ComponentRegistry) -> FastAPIServer:
+        return FastAPIServer(fastapi, service_manager, component_registry)
     
- server = FastAPIServer(host="0.0.0.0", port=8000)
 
- environment = server.boot(Module) # will start the http server
+environment = FastAPIServer.boot(Moudle, host="0.0.0.0", port=8000)
 ```
 
 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.5/performance-test/client.py

@@ -0,0 +1,155 @@
+"""
+Tests
+"""
+
+from abc import abstractmethod
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from aspyx_service import ServiceModule, delete, post, put, get, rest, Body
+from aspyx_service.service import  component, Component, Service, service
+
+from aspyx.di import module
+
+
+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.5/performance-test/main.py

@@ -0,0 +1,34 @@
+"""
+the server hosting the test services
+"""
+import logging
+import os
+
+from fastapi import FastAPI
+
+from aspyx_service import FastAPIServer, RequestContext
+from server import  ServerModule
+from aspyx.util import Logger
+
+
+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"))
+
+app = FastAPI()
+
+app.add_middleware(RequestContext)
+#app.add_middleware(TokenContextMiddleware)
+
+ServerModule.fastapi = app
+
+FastAPIServer.boot(ServerModule, host="0.0.0.0", port=PORT, start_thread= False)
+
+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.3/performance_tests → aspyx_service-0.10.5/performance-test}/performance-test.py

@@ -2,22 +2,97 @@
 Tests
 """
 import asyncio
-import logging
 import threading
 import time
+import logging
+
+from typing import Callable, TypeVar, Type, Awaitable, Any, Dict, cast
+
+from consul import Consul
+
+from aspyx_service import ConsulComponentRegistry, SessionManager
+
+from aspyx.di import module, Environment, create
+from aspyx.di.aop import advice, around, methods, Invocation
+from aspyx.util import Logger
+
+
+from aspyx_service.service import ServiceManager, ComponentRegistry, Channel
+
+Logger.configure(default_level=logging.INFO, levels={
+    "httpx": logging.CRITICAL,
+    "aspyx.di": logging.INFO,
+    "aspyx.di.aop": logging.INFO,
+    "aspyx.service": logging.INFO
+})
+
+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])
 
-from typing import Callable, TypeVar, Type, Awaitable, Any
+        channel.select_round_robin() # or select_first_url()
 
-from packages.aspyx_service.tests.common import service_manager, TestService, TestRestService, Pydantic, Data, \
-    TestAsyncRestService, TestAsyncService
-from packages.aspyx_service.tests.test_async_service import data
+        return invocation.proceed()
+
+@module(imports=[ClientModule])
+class TestModule:
+    def __init__(self):
+        pass
+
+    @create()
+    def create_session_storage(self) -> SessionManager.Storage:
+        return SessionManager.InMemoryStorage(max_size=1000, ttl=3600)
+
+    @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
 
-pydantic = Pydantic(i=1, f=1.0, b=True, s="s")
-data = Data(i=1, f=1.0, b=True, s="s")
+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()
@@ -43,6 +118,8 @@ def run_threaded_async_loops(name: str, loops: int, n_threads: int,  type: Type[
     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)
 
@@ -73,6 +150,8 @@ def run_threaded_sync_loops(name: str, loops: int, n_threads: int,  type: Type[T
     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)
 
@@ -99,10 +178,13 @@ def run_threaded_sync_loops(name: str, loops: int, n_threads: int,  type: Type[T
 
     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
 
-    manager = service_manager()
     loops = 1000
 
     # tests
@@ -131,7 +213,7 @@ async def main():
     # async
 
     await run_async_loops("async rest", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
-              lambda service: service.get("world"))
+                          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"),
@@ -166,7 +248,7 @@ async def main():
     # sync
 
     run_threaded_sync_loops("threaded sync json, 1 thread", loops, 1, TestService,
-                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             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"),
@@ -199,7 +281,5 @@ async def main():
                              manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
                              lambda service: service.hello("world"))
 
-
 if __name__ == "__main__":
     asyncio.run(main())
-

aspyx_service-0.10.5/performance-test/readme.txt

@@ -0,0 +1 @@
+uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1 --reload --log-level warning