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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.2
+Version: 0.10.3
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -70,19 +70,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 +115,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)
@@ -361,7 +365,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**:
  

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

@@ -34,19 +34,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 +79,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)
@@ -325,7 +329,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**:
  

aspyx_service-0.10.3/performance_tests/performance-test.py

@@ -0,0 +1,205 @@
+"""
+Tests
+"""
+import asyncio
+import logging
+import threading
+import time
+
+from typing import Callable, TypeVar, Type, Awaitable, Any
+
+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
+
+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")
+
+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):
+        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):
+        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")
+
+async def main():
+    # get service manager
+
+    manager = 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(TestAsyncService, 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())
+

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

@@ -2,7 +2,7 @@
 
 [project]
 name = "aspyx_service"
-version = "0.10.2"
+version = "0.10.3"
 description = "Aspyx Service framework"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/src/aspyx_service/channels.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel
 
 from aspyx.di.configuration import inject_value
 from aspyx.reflection import DynamicProxy, TypeDescriptor
+from aspyx.threading import ThreadLocal
 from .service import ServiceManager, ServiceCommunicationException
 
 from .service import ComponentDescriptor, ChannelInstances, ServiceException, channel, Channel, RemoteServiceException
@@ -28,6 +29,11 @@ class HTTPXChannel(Channel):
         "timeout"
     ]
 
+    # class properties
+
+    client_local = ThreadLocal[Client]()
+    async_client_local = ThreadLocal[AsyncClient]()
+
     # class methods
 
     @classmethod
@@ -61,8 +67,6 @@ class HTTPXChannel(Channel):
         super().__init__()
 
         self.timeout = 1000.0
-        self.client: Optional[Client] = None
-        self.async_client: Optional[AsyncClient] = None
         self.service_names: dict[Type, str] = {}
         self.deserializers: dict[Callable, Callable] = {}
 
@@ -95,24 +99,25 @@ class HTTPXChannel(Channel):
         for service in component_descriptor.services:
             self.service_names[service.type] = service.name
 
-        # make client
-
-        self.client = self.make_client()
-        self.async_client = self.make_async_client()
-
     # public
 
     def get_client(self) -> Client:
-        if self.client is None:
-            self.client = self.make_client()
+        client = self.client_local.get()
+
+        if client is None:
+            client = self.make_client()
+            self.client_local.set(client)
 
-        return self.client
+        return client
 
     def get_async_client(self) -> AsyncClient:
-        if self.async_client is None:
-            self.async_client = self.make_async_client()
+        async_client = self.async_client_local.get()
+
+        if async_client is None:
+            async_client = self.make_async_client()
+            self.async_client_local.set(async_client)
 
-        return self.async_client
+        return async_client
 
     def make_client(self) -> Client:
         return Client()  # base_url=url

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/src/aspyx_service/restchannel.py

@@ -249,16 +249,15 @@ class RestChannel(HTTPXChannel):
         try:
             result = None
             if call.type == "get":
-                result = await self.get_client().get(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+                result = await self.get_async_client().get(self.get_url() + url, params=query_params, timeout=self.timeout)
             elif call.type == "put":
-                result = await self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+                result = await self.get_async_client().put(self.get_url() + url, params=query_params, timeout=self.timeout)
             elif call.type == "delete":
-                result = await self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+                result = await self.get_async_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout)
             elif call.type == "post":
-                result = await self.get_client().post(self.get_url() + url, params=query_params, json=body,
-                                                timeout=self.timeout).json()
+                result = await self.get_async_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
 
-            return self.get_deserializer(invocation.type, invocation.method)(result)
+            return self.get_deserializer(invocation.type, invocation.method)(result.json())
         except ServiceCommunicationException:
             raise
 
@@ -285,15 +284,15 @@ class RestChannel(HTTPXChannel):
         try:
             result = None
             if call.type == "get":
-                result = self.get_client().get(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+                result = self.get_client().get(self.get_url() + url, params=query_params, timeout=self.timeout)
             elif call.type == "put":
-                result = self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+                result = self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout)
             elif call.type == "delete":
-                result = self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout).json()
+                result = self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout)
             elif call.type == "post":
-                result = self.get_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout).json()
+                result = self.get_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
 
-            return self.get_deserializer(invocation.type, invocation.method)(result)
+            return self.get_deserializer(invocation.type, invocation.method)(result.json())
         except ServiceCommunicationException:
             raise
 

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/src/aspyx_service/serialization.py

@@ -42,6 +42,9 @@ class TypeDeserializer:
         if is_dataclass(typ):
             field_deserializers = {f.name: TypeDeserializer(f.type) for f in fields(typ)}
             def deser_dataclass(value):
+                if is_dataclass(value):
+                    return value
+
                 return typ(**{
                     k: field_deserializers[k](v) for k, v in value.items()
                 })

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/src/aspyx_service/service.py

@@ -769,11 +769,12 @@ class ServiceManager:
 
         # check proxy
 
-        key = TypeAndChannel(type=component_descriptor.type, channel=preferred_channel)
+        channel_key = TypeAndChannel(type=component_descriptor.type, channel=preferred_channel)
+        proxy_key   = TypeAndChannel(type=service_type, channel=preferred_channel)
 
-        proxy = self.proxy_cache.get(key, None)
+        proxy = self.proxy_cache.get(proxy_key, None)
         if proxy is None:
-            channel_instance = self.channel_cache.get(key, None)
+            channel_instance = self.channel_cache.get(channel_key, None)
 
             if channel_instance is None:
                 address = self.find_service_address(component_descriptor, preferred_channel)
@@ -786,9 +787,9 @@ class ServiceManager:
                 # channel may have changed
 
                 if address.channel != preferred_channel:
-                    key = TypeAndChannel(type=component_descriptor.type, channel=address.channel)
+                    channel_key = TypeAndChannel(type=component_descriptor.type, channel=address.channel)
 
-                channel_instance = self.channel_cache.get(key, None)
+                channel_instance = self.channel_cache.get(channel_key, None)
                 if channel_instance is None:
                     # create channel
 
@@ -796,7 +797,7 @@ class ServiceManager:
 
                     # cache
 
-                    self.channel_cache[key] =  channel_instance
+                    self.channel_cache[channel_key] =  channel_instance
 
                     # and watch for changes in the addresses
 
@@ -805,7 +806,7 @@ class ServiceManager:
             # create proxy
 
             proxy = DynamicProxy.create(service_type, channel_instance)
-            self.proxy_cache[key] = proxy
+            self.proxy_cache[proxy_key] = proxy
 
         return proxy
 

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/tests/common.py

@@ -54,8 +54,13 @@ class Data:
     b: bool
     s: str
 
+class PydanticAndData(BaseModel):
     p: Pydantic
 
+@dataclass
+class DataAndPydantic:
+    d: Data
+
 # service
 
 @service(name="test-service", description="cool")

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/tests/test_async_service.py

@@ -6,7 +6,7 @@ import unittest
 from .common import TestAsyncService, TestAsyncRestService, Pydantic, Data, service_manager
 
 pydantic = Pydantic(i=1, f=1.0, b=True, s="s")
-data = Data(i=1, f=1.0, b=True, s="s", p=pydantic)
+data = Data(i=1, f=1.0, b=True, s="s")
 
 class TestAsyncRemoteService(unittest.IsolatedAsyncioTestCase):
     @classmethod
@@ -25,7 +25,7 @@ class TestAsyncRemoteService(unittest.IsolatedAsyncioTestCase):
         result_pydantic = await test_service.pydantic(pydantic)
         self.assertEqual(result_pydantic, pydantic)
 
-    async def test_dispatch_msgpack(self):
+    async def xtest_dispatch_msgpack(self):
         test_service = self.service_manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack")
 
         result = await test_service.hello("hello")
@@ -37,7 +37,7 @@ class TestAsyncRemoteService(unittest.IsolatedAsyncioTestCase):
         result_pydantic = await test_service.pydantic(pydantic)
         self.assertEqual(result_pydantic, pydantic)
 
-    async def xtest_dispatch_rest(self):
+    async def xtest_rest(self):
         test_service = self.service_manager.get_service(TestAsyncRestService, preferred_channel="rest")
 
         result = await test_service.get("hello")
@@ -49,10 +49,8 @@ class TestAsyncRemoteService(unittest.IsolatedAsyncioTestCase):
         result = await test_service.delete("hello")
         self.assertEqual(result, "hello")
 
-        #
-
-        result_pydantic = test_service.post_pydantic("message", pydantic)
+        result_pydantic = await test_service.post_pydantic("message", pydantic)
         self.assertEqual(result_pydantic, pydantic)
 
-        #result_data = test_service.post_data("message", data)
-        #self.assertEqual(result_data, data)
+        result_data = await test_service.post_data("message", data)
+        self.assertEqual(result_data, data)

aspyx_service-0.10.3/tests/test_serialization.py

@@ -0,0 +1,69 @@
+import unittest
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from aspyx_service.serialization import get_deserializer, get_serializer
+
+class Pydantic(BaseModel):
+    i : int
+    f : float
+    b: bool
+    s: str
+
+@dataclass
+class Data:
+    i: int
+    f: float
+    b: bool
+    s: str
+
+class PydanticAndData(BaseModel):
+    data: Data
+
+@dataclass
+class DataAndPydantic:
+    pydantic: Pydantic
+
+pydantic = Pydantic(i=1, f=1.0, b=True, s="s")
+data = Data(i=1, f=1.0, b=True, s="s")
+
+p_plus_d = PydanticAndData(data=data)
+d_plus_p = DataAndPydantic(pydantic=pydantic)
+
+class TestSerialization(unittest.TestCase):
+    def test_pydantic(self):
+        serializer = get_serializer(Pydantic)
+        deserializer = get_deserializer(Pydantic)
+
+        output = serializer(pydantic)
+        reverse = deserializer(output)
+
+        self.assertEqual(reverse, pydantic)
+
+    def test_data(self):
+        serializer = get_serializer(Data)
+        deserializer = get_deserializer(Data)
+
+        output = serializer(data)
+        reverse = deserializer(output)
+
+        self.assertEqual(reverse, data)
+
+    def test_pydantic_plus_data(self):
+        serializer = get_serializer(PydanticAndData)
+        deserializer = get_deserializer(PydanticAndData)
+
+        output = serializer(p_plus_d)
+        reverse = deserializer(output)
+
+        self.assertEqual(p_plus_d, p_plus_d)
+
+    def test_data_plus_pydantic(self):
+        serializer = get_serializer(DataAndPydantic)
+        deserializer = get_deserializer(DataAndPydantic)
+
+        output = serializer(d_plus_p)
+        reverse = deserializer(output)
+
+        self.assertEqual(reverse, d_plus_p)

{aspyx_service-0.10.2 → aspyx_service-0.10.3}/tests/test_service.py

@@ -7,7 +7,7 @@ import unittest
 from .common import TestService, TestRestService, Test, Pydantic, Data, service_manager
 
 pydantic = Pydantic(i=1, f=1.0, b=True, s="s")
-data = Data(i=1, f=1.0, b=True, s="s", p=pydantic)
+data = Data(i=1, f=1.0, b=True, s="s")
 
 
 class TestLocalService(unittest.TestCase):
@@ -37,7 +37,7 @@ class TestSyncRemoteService(unittest.TestCase):
     def setUpClass(cls):
         cls.service_manager = service_manager()
 
-    def xtest_dispatch_json(self):
+    def test_dispatch_json(self):
         test_service = self.service_manager.get_service(TestService, preferred_channel="dispatch-json")
 
         result = test_service.hello("hello")
@@ -49,7 +49,7 @@ class TestSyncRemoteService(unittest.TestCase):
         result_pydantic = test_service.pydantic(pydantic)
         self.assertEqual(result_pydantic, pydantic)
 
-    def xtest_dispatch_msgpack(self):
+    def test_dispatch_msgpack(self):
         test_service = self.service_manager.get_service(TestService, preferred_channel="dispatch-msgpack")
 
         result = test_service.hello("hello")
@@ -78,5 +78,5 @@ class TestSyncRemoteService(unittest.TestCase):
         result_pydantic = test_service.post_pydantic("message", pydantic)
         self.assertEqual(result_pydantic, pydantic)
 
-        #result_data= test_service.post_data("message", data)
-        #self.assertEqual(result_data, data)
+        result_data= test_service.post_data("message", data)
+        self.assertEqual(result_data, data)

aspyx_service-0.10.2/tests/__init__.py

@@ -1 +0,0 @@
-