orionis 0.217.0__py3-none-any.whl → 0.219.0__py3-none-any.whl

tests/support/standard/test_std.py

@@ -3,7 +3,7 @@ from orionis.luminate.test.test_case import TestCase
 
 class TestStdClass(TestCase):
 
-    def testInitializationAndAccess(self):
+    async def testInitializationAndAccess(self):
         obj = StdClass(
             first_name='Raul',
             last_name='Uñate',
@@ -12,49 +12,49 @@ class TestStdClass(TestCase):
         self.assertEqual(obj.first_name, 'Raul')
         self.assertEqual(obj.age, 31)
 
-    def testToDictReturnsCorrectData(self):
+    async def testToDictReturnsCorrectData(self):
         obj = StdClass(a=1, b=2)
         expected = {'a': 1, 'b': 2}
         self.assertEqual(obj.toDict(), expected)
 
-    def testUpdateAttributes(self):
+    async def testUpdateAttributes(self):
         obj = StdClass()
         obj.update(foo='bar', number=42)
         self.assertEqual(obj.foo, 'bar')
         self.assertEqual(obj.number, 42)
 
-    def testUpdateReservedAttributeRaisesError(self):
+    async def testUpdateReservedAttributeRaisesError(self):
         obj = StdClass()
         with self.assertRaises(ValueError):
             obj.update(__init__='bad')
 
-    def testUpdateConflictingAttributeRaisesError(self):
+    async def testUpdateConflictingAttributeRaisesError(self):
         obj = StdClass()
         with self.assertRaises(ValueError):
             obj.update(toDict='oops')
 
-    def testRemoveExistingAttributes(self):
+    async def testRemoveExistingAttributes(self):
         obj = StdClass(x=1, y=2)
         obj.remove('x')
         self.assertFalse(hasattr(obj, 'x'))
         self.assertTrue(hasattr(obj, 'y'))
 
-    def testRemoveNonExistingAttributeRaisesError(self):
+    async def testRemoveNonExistingAttributeRaisesError(self):
         obj = StdClass()
         with self.assertRaises(AttributeError):
             obj.remove('not_there')
 
-    def testFromDictCreatesEquivalentInstance(self):
+    async def testFromDictCreatesEquivalentInstance(self):
         data = {'a': 10, 'b': 20}
         obj = StdClass.from_dict(data)
         self.assertEqual(obj.toDict(), data)
 
-    def testReprAndStr(self):
+    async def testReprAndStr(self):
         obj = StdClass(x=5)
         self.assertIn("StdClass", repr(obj))
         self.assertIn("'x': 5", str(obj))
 
-    def testEquality(self):
+    async def testEquality(self):
         a = StdClass(x=1, y=2)
         b = StdClass(x=1, y=2)
         c = StdClass(x=3)

orionis/luminate/support/asyn_run.py

@@ -1,41 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Coroutine, TypeVar
-
-T = TypeVar("T")
-
-class AsyncExecutor:
-    """ Utility class to run asynchronous functions synchronously. """
-
-    @staticmethod
-    def run(callback: Coroutine[Any, Any, T]) -> T:
-        """
-        Runs an asynchronous coroutine in a synchronous context.
-
-        Parameters
-        ----------
-        callback : Coroutine[Any, Any, T]
-            The asynchronous coroutine to execute.
-
-        Returns
-        -------
-        T
-            The result of the coroutine execution.
-
-        Raises
-        ------
-        Exception
-            If the coroutine execution fails.
-        """
-        logging.getLogger('asyncio').setLevel(logging.WARNING)
-
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        try:
-            return loop.run_until_complete(callback)
-        except Exception as e:
-            raise RuntimeError(f"Error executing coroutine: {e}") from e