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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.3
+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)
 
@@ -166,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:
@@ -352,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
@@ -482,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.3 → 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)
 
@@ -130,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:
@@ -316,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
@@ -446,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.3/performance_tests → aspyx_service-0.10.4/performance-test}/performance-test.py

@@ -2,22 +2,91 @@
 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.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()
 
-from typing import Callable, TypeVar, Type, Awaitable, Any
+        return invocation.proceed()
 
-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
+@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
 
-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 +112,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 +144,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 +172,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
@@ -166,7 +242,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 +275,5 @@ async def main():
                              manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
                              lambda service: service.hello("world"))
 
-
 if __name__ == "__main__":
-    asyncio.run(main())
-
+    asyncio.run(main())

aspyx_service-0.10.4/performance-test/readme.txt

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

aspyx_service-0.10.4/performance-test/server.py

@@ -0,0 +1,154 @@
+"""
+Tests
+"""
+import os
+from typing import Optional
+
+from consul import Consul
+
+from aspyx.di import on_running, module, create
+from aspyx.di.aop import Invocation, advice, error
+from aspyx.exception import handle, ExceptionManager
+from aspyx_service import HealthCheckManager, ServiceModule, ConsulComponentRegistry
+from aspyx_service.service import ChannelAddress, Server, \
+    component_services, AbstractComponent, implementation, health, ComponentRegistry
+
+from client import ClientModule, TestService, TestAsyncService, Data, Pydantic, TestRestService, TestAsyncRestService, TestComponent
+
+
+# implementation classes
+
+@implementation()
+class TestServiceImpl(TestService):
+    def __init__(self):
+        pass
+
+    def hello(self, message: str) -> str:
+        return message
+
+    def throw(self, message: str) -> str:
+        raise Exception(message)
+
+    def data(self, data: Data) -> Data:
+        return data
+
+    def pydantic(self, data: Pydantic) -> Pydantic:
+        return data
+
+@implementation()
+class TestAsyncServiceImpl(TestAsyncService):
+    def __init__(self):
+        pass
+
+    async def hello(self, message: str) -> str:
+        return message
+
+    async def data(self, data: Data) -> Data:
+        return data
+
+    async def pydantic(self, data: Pydantic) -> Pydantic:
+        return data
+
+@implementation()
+class TestRestServiceImpl(TestRestService):
+    def __init__(self):
+        pass
+
+    def get(self, message: str) -> str:
+        return message
+
+    def put(self, message: str) -> str:
+        return message
+
+    def post_pydantic(self, message: str, data: Pydantic) -> Pydantic:
+        return data
+
+    def post_data(self, message: str, data: Data) -> Data:
+        return data
+
+    def delete(self, message: str) -> str:
+        return message
+
+@implementation()
+class TestAsyncRestServiceImpl(TestAsyncRestService):
+    def __init__(self):
+        pass
+
+    async def get(self, message: str) -> str:
+        return message
+
+    async def put(self, message: str) -> str:
+        return message
+
+    async def post_pydantic(self, message: str, data: Pydantic) -> Pydantic:
+        return data
+
+    async def post_data(self, message: str, data: Data) -> Data:
+        return data
+
+    async def delete(self, message: str) -> str:
+        return message
+
+@implementation()
+@health("/health")
+@advice
+class TestComponentImpl(AbstractComponent, TestComponent):
+    # constructor
+
+    def __init__(self):
+        super().__init__()
+
+        self.health_check_manager : Optional[HealthCheckManager] = None
+        self.exception_manager = ExceptionManager()
+
+    # exception handler
+
+    @handle()
+    def handle_exception(self, exception: Exception):
+        print("caught exception!")
+        return exception
+
+    # aspects
+
+    @error(component_services(TestComponent))
+    def catch(self, invocation: Invocation):
+        return self.exception_manager.handle(invocation.exception)
+
+    # lifecycle
+
+    @on_running()
+    def setup_exception_handlers(self):
+        self.exception_manager.collect_handlers(self)
+
+    # implement
+
+    async def get_health(self) -> HealthCheckManager.Health:
+        return HealthCheckManager.Health()
+
+    def get_addresses(self, port: int) -> list[ChannelAddress]:
+        return [
+            ChannelAddress("rest", f"http://{Server.get_local_ip()}:{port}"),
+            ChannelAddress("dispatch-json", f"http://{Server.get_local_ip()}:{port}"),
+            ChannelAddress("dispatch-msgpack", f"http://{Server.get_local_ip()}:{port}")
+        ]
+
+    def startup(self) -> None:
+        print("### startup")
+
+    def shutdown(self) -> None:
+        print("### shutdown")
+
+# module
+
+@module(imports=[ClientModule, ServiceModule])
+class ServerModule:
+    def __init__(self):
+        pass
+
+    #@create()
+    #def create_yaml_source(self) -> YamlConfigurationSource:
+    #    return YamlConfigurationSource(f"{Path(__file__).parent}/config.yaml")
+
+    @create()
+    def create_registry(self) -> ComponentRegistry:
+        return ConsulComponentRegistry(port=int(os.getenv("FAST_API_PORT", 8000)), consul=Consul(host="localhost", port=8500))

aspyx_service-0.10.4/performance-test/start_server_8000.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+export FAST_API_PORT=8000
+uvicorn main:app --host 0.0.0.0 --port $FAST_API_PORT --workers 1 --log-level warning

aspyx_service-0.10.4/performance-test/start_server_8001.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+export FAST_API_PORT=8001
+uvicorn main:app --host 0.0.0.0 --port $FAST_API_PORT --workers 1 --log-level warning

{aspyx_service-0.10.3 → aspyx_service-0.10.4}/pyproject.toml

@@ -2,18 +2,19 @@
 
 [project]
 name = "aspyx_service"
-version = "0.10.3"
+version = "0.10.4"
 description = "Aspyx Service framework"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.9"
 dependencies = [
-    "aspyx>=1.5.1",
+    "aspyx>=1.5.3",
     "python-consul2~=0.1.5",
     "fastapi~=0.115.13",
     "httpx~=0.28.1",
     "msgpack~=1.1.1",
+    "cachetools~= 5.5.2",
     "uvicorn[standard]"
 ]
 
@@ -27,5 +28,15 @@ source = "src"
 [tool.hatch.build.targets.wheel]
 packages = ["src/aspyx_service"]
 
+[tool.hatch.envs.test]
+dependencies = [
+  ".",
+  "pytest",
+  "pytest-cov",
+  "pytest-asyncio",
+  "anyio",
+  "PyJWT"
+]
+
 [tool.hatch.metadata]
 allow-direct-references = true