orionis 0.231.0__py3-none-any.whl → 0.233.0__py3-none-any.whl

orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.231.0"
+VERSION = "0.233.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/luminate/support/inspection/reflexion_instance.py

@@ -1,6 +1,8 @@
 from typing import Any, Type, Dict, List, Tuple, Callable, Optional
 import inspect
 
+from orionis.luminate.support.asynchrony.async_io import AsyncIO
+
 class ReflexionInstance:
     """A reflection object encapsulating a class instance.
 
@@ -26,13 +28,6 @@ class ReflexionInstance:
         -------
         str
             The name of the class
-
-        Examples
-        --------
-        >>> obj = SomeClass()
-        >>> reflex = ReflexionInstance(obj)
-        >>> reflex.getClassName()
-        'SomeClass'
         """
         return self._instance.__class__.__name__
 
@@ -43,11 +38,6 @@ class ReflexionInstance:
         -------
         Type
             The class object of the instance
-
-        Examples
-        --------
-        >>> reflex.getClass() is SomeClass
-        True
         """
         return self._instance.__class__
 
@@ -58,11 +48,6 @@ class ReflexionInstance:
         -------
         str
             The module name
-
-        Examples
-        --------
-        >>> reflex.getModuleName()
-        'some_module'
         """
         return self._instance.__class__.__module__
 
@@ -73,13 +58,60 @@ class ReflexionInstance:
         -------
         Dict[str, Any]
             Dictionary of attribute names and their values
+        """
+        attributes : dict  = vars(self._instance)
+        class_name : str = self.getClassName()
+        out_attributes = {}
+        for attr, value in attributes.items():
+            out_attributes[str(attr).replace(f"_{class_name}", "")] = value
+        return out_attributes
+
+    def getPublicAttributes(self) -> Dict[str, Any]:
+        """Get all public attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of public attribute names and their values
+        """
+        attributes : dict = vars(self._instance)
+        out_attributes = {}
+        for attr, value in attributes.items():
+            if not str(attr).startswith("_"):
+                out_attributes[attr] = value
+        return out_attributes
+
+    def getPrivateAttributes(self) -> Dict[str, Any]:
+        """Get all private attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of private attribute names and their values
+        """
+        attributes : dict = vars(self._instance)
+        class_name : str = self.getClassName()
+        out_attributes = {}
+        for attr, value in attributes.items():
+            if str(attr).startswith(f"_{class_name}"):
+                out_attributes[str(attr).replace(f"_{class_name}", "")] = value
+        return out_attributes
 
-        Examples
-        --------
-        >>> reflex.getAttributes()
-        {'attr1': value1, 'attr2': value2}
+    def getProtectedAttributes(self) -> Dict[str, Any]:
+        """Get all Protected attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of Protected attribute names and their values
         """
-        return vars(self._instance)
+        attributes : dict = vars(self._instance)
+        class_name : str = self.getClassName()
+        out_attributes = {}
+        for attr, value in attributes.items():
+            if str(attr).startswith("_") and not str(attr).startswith("__") and not str(attr).startswith(f"_{class_name}"):
+                out_attributes[attr] = value
+        return out_attributes
 
     def getMethods(self) -> List[str]:
         """Get all method names of the instance.
@@ -88,41 +120,165 @@ class ReflexionInstance:
         -------
         List[str]
             List of method names
+        """
+        class_name = self.getClassName()
+        methods = [name for name, _ in inspect.getmembers(
+            self._instance,
+            predicate=inspect.ismethod
+        )]
+
+        out_methods = []
+        for method in methods:
+            out_methods.append(method.replace(f"_{class_name}", ""))
 
-        Examples
-        --------
-        >>> reflex.getMethods()
-        ['method1', 'method2']
+        return out_methods
+
+    def getProtectedMethods(self) -> List[str]:
+        """Get all protected method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of protected method names, excluding private methods (starting with '_')
         """
-        return [name for name, _ in inspect.getmembers(
+        class_name = self.getClassName()
+        methods = [name for name, _ in inspect.getmembers(
             self._instance,
             predicate=inspect.ismethod
         )]
 
+        out_methods = []
+        for method in methods:
+            if method.startswith("_") and not method.startswith("__") and not method.startswith(f"_{class_name}"):
+                out_methods.append(method)
+
+        return out_methods
+
+    def getPrivateMethods(self) -> List[str]:
+        """Get all private method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of private method names, excluding protected methods (starting with '_')
+        """
+        class_name = self.getClassName()
+        methods = [name for name, _ in inspect.getmembers(
+            self._instance,
+            predicate=inspect.ismethod
+        )]
+
+        out_methods = []
+        for method in methods:
+            if method.startswith(f"_{class_name}"):
+                out_methods.append(method.replace(f"_{class_name}", ""))
+
+        return out_methods
+
+    def getAsyncMethods(self) -> List[str]:
+        """
+        Get all asynchronous method names of the instance that are not static methods.
+
+        Returns
+        -------
+        List[str]
+            List of asynchronous method names
+        """
+        obj = self._instance
+        cls = obj if inspect.isclass(obj) else obj.__class__
+        class_name = self.getClassName()
+        methods = [
+            name for name, func in inspect.getmembers(obj, inspect.iscoroutinefunction)
+            if not isinstance(inspect.getattr_static(cls, name, None), staticmethod)
+        ]
+
+        out_methods = []
+        for method in methods:
+            out_methods.append(method.replace(f"_{class_name}", ""))
+
+        return out_methods
+
+    def getSyncMethods(self) -> List[str]:
+        """
+        Get all synchronous method names of the instance that are not static methods.
+
+        Returns
+        -------
+        List[str]
+            List of synchronous method names
+        """
+        obj = self._instance
+        cls = obj if inspect.isclass(obj) else obj.__class__
+        class_name = self.getClassName()
+        methods = [
+            name for name, func in inspect.getmembers(obj, predicate=inspect.ismethod)
+            if not inspect.iscoroutinefunction(func) and
+            not isinstance(inspect.getattr_static(cls, name, None), staticmethod)
+        ]
+
+        out_methods = []
+        for method in methods:
+            out_methods.append(method.replace(f"_{class_name}", ""))
+
+        return out_methods
+
+    def getClassMethods(self) -> List[str]:
+        """Get all class method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of class method names.
+        """
+        return [
+            name for name in dir(self._instance.__class__)
+            if isinstance(inspect.getattr_static(self._instance.__class__, name), classmethod)
+        ]
+
     def getStaticMethods(self) -> List[str]:
         """Get all static method names of the instance.
 
         Returns
         -------
         List[str]
-            List of static method names, excluding private methods (starting with '_')
-
-        Examples
-        --------
-        >>> class MyClass:
-        ...     @staticmethod
-        ...     def static_method(): pass
-        ...     @staticmethod
-        ...     def _private_static(): pass
-        ...
-        >>> reflex = ReflexionInstance(MyClass())
-        >>> reflex.getStaticMethods()
-        ['static_method']
+            List of static method names.
         """
         return [
             name for name in dir(self._instance.__class__)
-            if not name.startswith('_') and
-            isinstance(inspect.getattr_static(self._instance.__class__, name), staticmethod)
+            if isinstance(inspect.getattr_static(self._instance.__class__, name), staticmethod)
+        ]
+
+    def getAsyncStaticMethods(self) -> List[str]:
+        """
+        Get all asynchronous method names of the instance that are not static methods.
+
+        Returns
+        -------
+        List[str]
+            List of asynchronous method names
+        """
+        obj = self._instance
+        cls = obj if inspect.isclass(obj) else obj.__class__
+        return [
+            name for name, func in inspect.getmembers(obj, inspect.iscoroutinefunction)
+            if isinstance(inspect.getattr_static(cls, name, None), staticmethod)
+        ]
+
+    def getSyncStaticMethods(self) -> List[str]:
+        """
+        Get all synchronous static method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of synchronous static method names
+        """
+        obj = self._instance
+        cls = obj if inspect.isclass(obj) else obj.__class__
+        return [
+            name for name, func in inspect.getmembers(cls, inspect.isfunction)
+            if not inspect.iscoroutinefunction(func) and
+            isinstance(inspect.getattr_static(cls, name, None), staticmethod)
         ]
 
     def getPropertyNames(self) -> List[str]:
@@ -132,103 +288,117 @@ class ReflexionInstance:
         -------
         List[str]
             List of property names
-
-        Examples
-        --------
-        >>> reflex.getPropertyNames()
-        ['prop1', 'prop2']
         """
         return [name for name, _ in inspect.getmembers(
             self._instance.__class__,
             lambda x: isinstance(x, property)
         )]
 
-    def callMethod(self, methodName: str, *args: Any, **kwargs: Any) -> Any:
-        """Call a method on the instance.
+    def getProperty(self, propertyName: str) -> Any:
+        """Get the value of a property.
 
         Parameters
         ----------
-        methodName : str
-            Name of the method to call
-        *args : Any
-            Positional arguments for the method
-        **kwargs : Any
-            Keyword arguments for the method
+        propertyName : str
+            Name of the property
 
         Returns
         -------
         Any
-            The return value of the method
+            The value of the property
 
         Raises
         ------
         AttributeError
-            If the method doesn't exist
-
-        Examples
-        --------
-        >>> reflex.callMethod('calculate', 2, 3)
-        5
+            If the property doesn't exist or is not a property
         """
-        method = getattr(self._instance, methodName)
-        return method(*args, **kwargs)
+        attr = getattr(self._instance.__class__, propertyName, None)
+        if isinstance(attr, property) and attr.fget is not None:
+            return getattr(self._instance, propertyName)
+        raise AttributeError(f"{propertyName} is not a property or doesn't have a getter.")
 
-    def getMethodSignature(self, methodName: str) -> inspect.Signature:
-        """Get the signature of a method.
+    def getPropertySignature(self, propertyName: str) -> inspect.Signature:
+        """Get the signature of a property.
 
         Parameters
         ----------
-        methodName : str
-            Name of the method
+        propertyName : str
+            Name of the property
 
         Returns
         -------
         inspect.Signature
-            The method signature
+            The property signature
 
         Raises
         ------
         AttributeError
-            If the method doesn't exist
-
-        Examples
-        --------
-        >>> sig = reflex.getMethodSignature('calculate')
-        >>> str(sig)
-        '(x, y)'
+            If the property doesn't exist or is not a property
         """
-        method = getattr(self._instance, methodName)
-        if callable(method):
-            return inspect.signature(method)
+        attr = getattr(self._instance.__class__, propertyName, None)
+        if isinstance(attr, property) and attr.fget is not None:
+            return inspect.signature(attr.fget)
+        raise AttributeError(f"{propertyName} is not a property or doesn't have a getter.")
 
-    def getPropertySignature(self, propertyName: str) -> inspect.Signature:
-        """Get the signature of a property getter.
+    def callMethod(self, methodName: str, *args: Any, **kwargs: Any) -> Any:
+        """Call a method on the instance.
 
         Parameters
         ----------
-        propertyName : str
-            Name of the property
+        methodName : str
+            Name of the method to call
+        *args : Any
+            Positional arguments for the method
+        **kwargs : Any
+            Keyword arguments for the method
 
         Returns
         -------
-        inspect.Signature
-            The property's getter method signature
+        Any
+            The result of the method call
 
         Raises
         ------
         AttributeError
-            If the property doesn't exist or is not a property
+            If the method does not exist on the instance
+        TypeError
+            If the method is not callable
+        """
+
+        if methodName in self.getPrivateMethods():
+            methodName = f"_{self.getClassName()}{methodName}"
+
+        method = getattr(self._instance, methodName, None)
+
+        if method is None:
+            raise AttributeError(f"'{self.getClassName()}' object has no method '{methodName}'.")
+        if not callable(method):
+            raise TypeError(f"'{methodName}' is not callable on '{self.getClassName()}'.")
+
+        if inspect.iscoroutinefunction(method):
+            return AsyncIO.run(method(*args, **kwargs))
+
+        return method(*args, **kwargs)
+
+    def getMethodSignature(self, methodName: str) -> inspect.Signature:
+        """Get the signature of a method.
+
+        Parameters
+        ----------
+        methodName : str
+            Name of the method
 
-        Examples
-        --------
-        >>> sig = reflex.getPropertySignature('config')
-        >>> str(sig)
-        '(self)'
+        Returns
+        -------
+        inspect.Signature
+            The method signature
         """
-        attr = getattr(type(self._instance), propertyName, None)
-        if isinstance(attr, property) and attr.fget is not None:
-            return inspect.signature(attr.fget)
-        raise AttributeError(f"{propertyName} is not a property or doesn't have a getter.")
+        if methodName in self.getPrivateMethods():
+            methodName = f"_{self.getClassName()}{methodName}"
+
+        method = getattr(self._instance, methodName)
+        if callable(method):
+            return inspect.signature(method)
 
     def getDocstring(self) -> Optional[str]:
         """Get the docstring of the instance's class.
@@ -237,11 +407,6 @@ class ReflexionInstance:
         -------
         Optional[str]
             The class docstring, or None if not available
-
-        Examples
-        --------
-        >>> reflex.getDocstring()
-        'This class does something important.'
         """
         return self._instance.__class__.__doc__
 
@@ -252,11 +417,6 @@ class ReflexionInstance:
         -------
         Tuple[Type, ...]
             Tuple of base classes
-
-        Examples
-        --------
-        >>> reflex.getBaseClasses()
-        (<class 'object'>,)
         """
         return self._instance.__class__.__bases__
 
@@ -272,11 +432,6 @@ class ReflexionInstance:
         -------
         bool
             True if the instance is of the specified class
-
-        Examples
-        --------
-        >>> reflex.isInstanceOf(SomeClass)
-        True
         """
         return isinstance(self._instance, cls)
 
@@ -287,13 +442,6 @@ class ReflexionInstance:
         -------
         Optional[str]
             The source code if available, None otherwise
-
-        Examples
-        --------
-        >>> print(reflex.getSourceCode())
-        class SomeClass:
-            def __init__(self):
-                ...
         """
         try:
             return inspect.getsource(self._instance.__class__)
@@ -307,11 +455,6 @@ class ReflexionInstance:
         -------
         Optional[str]
             The file path if available, None otherwise
-
-        Examples
-        --------
-        >>> reflex.getFileLocation()
-        '/path/to/module.py'
         """
         try:
             return inspect.getfile(self._instance.__class__)
@@ -325,11 +468,6 @@ class ReflexionInstance:
         -------
         Dict[str, Any]
             Dictionary of attribute names and their type annotations
-
-        Examples
-        --------
-        >>> reflex.getAnnotations()
-        {'name': str, 'value': int}
         """
         return self._instance.__class__.__annotations__
 
@@ -345,11 +483,6 @@ class ReflexionInstance:
         -------
         bool
             True if the attribute exists
-
-        Examples
-        --------
-        >>> reflex.hasAttribute('important_attr')
-        True
         """
         return hasattr(self._instance, name)
 
@@ -370,13 +503,9 @@ class ReflexionInstance:
         ------
         AttributeError
             If the attribute doesn't exist
-
-        Examples
-        --------
-        >>> reflex.getAttribute('count')
-        42
         """
-        return getattr(self._instance, name)
+        attrs = self.getAttributes()
+        return attrs.get(name, getattr(self._instance, name, None))
 
     def setAttribute(self, name: str, value: Any) -> None:
         """Set an attribute value.
@@ -392,29 +521,60 @@ class ReflexionInstance:
         ------
         AttributeError
             If the attribute is read-only
+        """
+        if callable(value):
+            raise AttributeError(f"Cannot set attribute '{name}' to a callable.")
+        setattr(self._instance, name, value)
+
+    def removeAttribute(self, name: str) -> None:
+        """Remove an attribute from the instance.
 
-        Examples
-        --------
-        >>> reflex.setAttribute('count', 100)
+        Parameters
+        ----------
+        name : str
+            The attribute name to remove
+
+        Raises
+        ------
+        AttributeError
+            If the attribute doesn't exist or is read-only
         """
+        if not hasattr(self._instance, name):
+            raise AttributeError(f"'{self.getClassName()}' object has no attribute '{name}'.")
+        delattr(self._instance, name)
+
+    def setMacro(self, name: str, value: Callable) -> None:
+        """Set a callable attribute value.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+        value : Callable
+            The callable to set
+
+        Raises
+        ------
+        AttributeError
+            If the value is not callable
+        """
+        if not callable(value):
+            raise AttributeError(f"The value for '{name}' must be a callable.")
         setattr(self._instance, name, value)
 
-    def getCallableMembers(self) -> Dict[str, Callable]:
-        """Get all callable members (methods) of the instance.
+    def removeMacro(self, name: str) -> None:
+        """Remove a callable attribute from the instance.
 
-        Returns
-        -------
-        Dict[str, Callable]
-            Dictionary of method names and their callable objects
-
-        Examples
-        --------
-        >>> reflex.getCallableMembers()
-        {'calculate': <bound method SomeClass.calculate>, ...}
-        """
-        return {
-            name: member for name, member in inspect.getmembers(
-                self._instance,
-                callable
-            ) if not name.startswith('__')
-        }
+        Parameters
+        ----------
+        name : str
+            The attribute name to remove
+
+        Raises
+        ------
+        AttributeError
+            If the attribute doesn't exist or is not callable
+        """
+        if not hasattr(self._instance, name) or not callable(getattr(self._instance, name)):
+            raise AttributeError(f"'{self.getClassName()}' object has no callable macro '{name}'.")
+        delattr(self._instance, name)

{orionis-0.231.0.dist-info → orionis-0.233.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.231.0
+Version: 0.233.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.231.0.dist-info → orionis-0.233.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console.py,sha256=4gYWxf0fWYgJ4RKwARvnTPh06FL3GJ6SAZ7R2NzOICw,1342
-orionis/framework.py,sha256=N03ehWIO3Lpa18h6NyDaoi8pIFeyLEn9PPlGQObIxxU,1458
+orionis/framework.py,sha256=zMVqUWppG3gKA3WkFIStp5LPdnRnvB_1vZjloIBbWv8,1458
 orionis/installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/installer/manager.py,sha256=Li4TVziRXWfum02xNG4JHwbnLk-u8xzHjdqKz-D894k,2755
 orionis/installer/output.py,sha256=7O9qa2xtXMB_4ZvVi-Klneom9YazwygAd_4uYAoxhbU,8548
@@ -173,7 +173,7 @@ orionis/luminate/support/inspection/reflection.py,sha256=xUILK5eEkTqXiAaOWVjEn_u
 orionis/luminate/support/inspection/reflexion_abstract.py,sha256=nImlP07TpsT0azgIafGVZfSv1THrBoJOlNSSr9vDKiE,10848
 orionis/luminate/support/inspection/reflexion_concrete.py,sha256=1ISuy2L6Oser-EhmpuGALmbauh7Z-X8Rx1YYgt5CabQ,7543
 orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py,sha256=z1cAscuG6a1E4ZJmwkp9HVQ0yhTAeFYKfnnyR_M-RFI,7480
-orionis/luminate/support/inspection/reflexion_instance.py,sha256=LNAgw4sZvHT7UMiObHTGk7xgqpIeKYHAQRgRpuPfEas,10842
+orionis/luminate/support/inspection/reflexion_instance.py,sha256=GFtJMehIZq58jVJ8SOofQuwgk4IgWGV-g2PPGkKb24o,17598
 orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=PI_VSH8baxjPgheOYc9tQAlLq9mjxGm5zCOr-bLVksg,9406
 orionis/luminate/support/inspection/reflexion_module.py,sha256=OgBXpqNJHkmq-gX4rqFStv-WVNe9R38RsgUgfHpak8k,405
 orionis/luminate/support/inspection/reflexion_module_with_classname.py,sha256=YZHZI0XUZkSWnq9wrGxrIXtI64nY9yVSZoMe7PZXq8Y,620
@@ -231,13 +231,13 @@ tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/support/inspection/test_reflection_abstract.py,sha256=6w8vm8H_fR4Z-KYjQGm8bq-HcetlpQl0EsDmDy3WzQ8,9311
 tests/support/inspection/test_reflection_concrete.py,sha256=3BWSU7MkFEv2UgAVAwhiaMrzEwAyDBBJCa6edOENKSU,6782
 tests/support/inspection/test_reflection_concrete_with_abstract.py,sha256=85cV9loDvtLG7sUxD6n_Ja0KV3x8FYakE2Z0W2Iruu8,4680
-tests/support/inspection/test_reflection_instance.py,sha256=8XKkEhboESLG2UaJ-STJ8STe7mUO4YDkKy01kiiGvkI,7197
+tests/support/inspection/test_reflection_instance.py,sha256=fapzzH2Qyacsy-S1I2Uq9k3B6fZ3Qbb3IJxvx451zoU,12668
 tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=l6tidHJUJpWhol-E5GfQEpMZ5gIVZFsegwVtMk8tYhs,4089
 tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/fakes/fake_reflection_abstract.py,sha256=7qtz44brfFzE4oNYi9kIsvdWP79nP2FnzSz-0bU__pg,5045
 tests/support/inspection/fakes/fake_reflection_concrete.py,sha256=j6gzsxE3xq5oJ30H_Hm1RsUwEY3jOYBu4sclxtD1ayo,1047
 tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py,sha256=ibCjrtNM6BMf5Z5VMvat7E6zOAk5g9z--gj4ykKJWY8,2118
-tests/support/inspection/fakes/fake_reflection_instance.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
+tests/support/inspection/fakes/fake_reflection_instance.py,sha256=P5lSFiGPLLAPOIRmw4VE3YWctxlqmXARRiWMSGLrg3E,1382
 tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py,sha256=SfL8FuFmr650RlzXTrP4tGMfsPVZLhOxVnBXu_g1POg,1471
 tests/support/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/parsers/test_exception_parser.py,sha256=s-ZRbxyr9bs5uis2SM0IN-vCc-AJhWqRnEMIVgeEFXE,2363
@@ -249,9 +249,9 @@ tests/support/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 tests/support/patterns/test_singleton.py,sha256=U5uwpgGcP7-fIazsnFLwg30mmc24S62udhVIHuL-scY,634
 tests/support/standard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/standard/test_std.py,sha256=bJ5LV_OKEEZa_Bk3PTk9Kapk6qECLzcKf0hfR_x2QqM,2042
-orionis-0.231.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.231.0.dist-info/METADATA,sha256=2pqpyP5KUXDaYxwy7LDaeiXSoiLgz63YsUh3SujLclk,3003
-orionis-0.231.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.231.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.231.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.231.0.dist-info/RECORD,,
+orionis-0.233.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.233.0.dist-info/METADATA,sha256=gp1CXdBLUnA91O29GEY1b6JD8w-kUcrK4y6nQdfTZHw,3003
+orionis-0.233.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.233.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.233.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.233.0.dist-info/RECORD,,

tests/support/inspection/fakes/fake_reflection_instance.py

@@ -1,39 +1,21 @@
+import asyncio
+
 class BaseFakeClass:
     pass
 
 class FakeClass(BaseFakeClass):
-    """This is a test class for ReflexionInstance.
-
-    Attributes
-    ----------
-    public_attr : int
-        An example public attribute
-    _private_attr : str
-        An example "private" attribute
-    """
+    """This is a test class for ReflexionInstance."""
 
     class_attr: str = "class_value"
 
     def __init__(self) -> None:
         self.public_attr = 42
-        self._private_attr = "secret"
+        self._protected_attr = "protected"
+        self.__private_attr = "private"
         self.dynamic_attr = None
 
-    def instance_method(self, x: int, y: int) -> int:
-        """Adds two numbers.
-
-        Parameters
-        ----------
-        x : int
-            First number
-        y : int
-            Second number
-
-        Returns
-        -------
-        int
-            The sum of x and y
-        """
+    def instanceMethod(self, x: int, y: int) -> int:
+        """Adds two numbers."""
         return x + y
 
     @property
@@ -42,19 +24,29 @@ class FakeClass(BaseFakeClass):
         return f"Value: {self.public_attr}"
 
     @classmethod
-    def class_method(cls) -> str:
+    def classMethod(cls) -> str:
         """A class method."""
         return f"Class attr: {cls.class_attr}"
 
     @staticmethod
-    def static_method(text: str) -> str:
+    def staticMethod(text: str) -> str:
         """A static method."""
         return text.upper()
 
-    def __private_method(self) -> str:
+    @staticmethod
+    async def staticAsyncMethod(text: str) -> str:
+        """An asynchronous static method."""
+        await asyncio.sleep(0.1)
+        return text.upper()
+
+    def __privateMethod(self) -> str:
         """A 'private' method."""
         return "This is private"
 
-    def _protected_method(self) -> str:
+    def _protectedMethod(self) -> str:
         """A 'protected' method."""
-        return "This is protected"
+        return "This is protected"
+
+    async def asyncMethod(self) -> str:
+        """An async method."""
+        return "This is async"

tests/support/inspection/test_reflection_instance.py

@@ -38,21 +38,89 @@ class TestReflectionInstance(TestCase):
         reflex = Reflection.instance(FakeClass())
         attributes = reflex.getAttributes()
         self.assertTrue("public_attr" in attributes)
-        self.assertTrue("_private_attr" in attributes)
+        self.assertTrue("__private_attr" in attributes)
         self.assertTrue("dynamic_attr" in attributes)
 
+    async def testReflectionInstanceGetPublicAttributes(self):
+        """Ensure getPublicAttributes returns all public attributes."""
+        reflex = Reflection.instance(FakeClass())
+        attributes = reflex.getPublicAttributes()
+        self.assertTrue("public_attr" in attributes)
+        self.assertTrue("dynamic_attr" in attributes)
+
+    async def testReflectionInstanceGetProtectedAttributes(self):
+        """Check that getProtectedAttributes returns all protected attributes."""
+        reflex = Reflection.instance(FakeClass())
+        attributes = reflex.getProtectedAttributes()
+        self.assertTrue("_protected_attr" in attributes)
+
+    async def testReflectionInstanceGetPrivateAttributes(self):
+        """Ensure getPrivateAttributes returns all private attributes."""
+        reflex = Reflection.instance(FakeClass())
+        attributes = reflex.getPrivateAttributes()
+        self.assertTrue("__private_attr" in attributes)
+
     async def testReflectionInstanceGetMethods(self):
         """Ensure getMethods returns all methods of the class."""
         reflex = Reflection.instance(FakeClass())
         methods = reflex.getMethods()
-        self.assertTrue("instance_method" in methods)
-        self.assertTrue("class_method" in methods)
+        self.assertTrue("__privateMethod" in methods)
+        self.assertTrue("_protectedMethod" in methods)
+        self.assertTrue("asyncMethod" in methods)
+        self.assertTrue("classMethod" in methods)
+        self.assertTrue("instanceMethod" in methods)
+
+    async def testReflectionInstanceGetProtectedMethods(self):
+        """Check that getProtectedMethods returns all protected methods."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getProtectedMethods()
+        self.assertTrue("_protectedMethod" in methods)
+
+    async def testReflectionInstanceGetPrivateMethods(self):
+        """Ensure getPrivateMethods returns all private methods."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getPrivateMethods()
+        self.assertTrue("__privateMethod" in methods)
+
+    async def testReflectionInstanceGetAsyncMethods(self):
+        """Check that getAsyncMethods returns all async methods of the class."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getAsyncMethods()
+        self.assertTrue("asyncMethod" in methods)
+
+    async def testReflectionInstanceGetSyncMethods(self):
+        """Check that getASyncMethods returns all async methods of the class."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getSyncMethods()
+        self.assertTrue("__privateMethod" in methods)
+        self.assertTrue("_protectedMethod" in methods)
+        self.assertTrue("classMethod" in methods)
+        self.assertTrue("instanceMethod" in methods)
+
+    async def testReflectionInstanceGetClassMethods(self):
+        """Verify getClassMethods returns all class methods of the class."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getClassMethods()
+        self.assertTrue("classMethod" in methods)
 
     async def testReflectionInstanceGetStaticMethods(self):
         """Verify getStaticMethods returns all static methods of the class."""
         reflex = Reflection.instance(FakeClass())
         methods = reflex.getStaticMethods()
-        self.assertTrue("static_method" in methods)
+        self.assertTrue("staticAsyncMethod" in methods)
+        self.assertTrue("staticMethod" in methods)
+
+    async def testReflectionInstanceGetAsyncStaticMethods(self):
+        """Ensure getSyncMethods returns all sync methods of the class."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getAsyncStaticMethods()
+        self.assertTrue("staticAsyncMethod" in methods)
+
+    async def testReflectionInstanceGetSyncStaticMethods(self):
+        """Check that getSyncMethods returns all sync methods of the class."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getSyncStaticMethods()
+        self.assertTrue("staticMethod" in methods)
 
     async def testReflectionInstanceGetPropertyNames(self):
         """Check that getPropertyNames returns all property names."""
@@ -60,17 +128,31 @@ class TestReflectionInstance(TestCase):
         properties = reflex.getPropertyNames()
         self.assertTrue("computed_property" in properties)
 
+    async def testReflectionInstanceGetProperty(self):
+        """Ensure getProperty retrieves the correct property value."""
+        reflex = Reflection.instance(FakeClass())
+        property_value = reflex.getProperty("computed_property")
+        self.assertEqual(property_value, "Value: 42")
+
     async def testReflectionInstanceCallMethod(self):
         """Ensure callMethod correctly invokes a method with arguments."""
         reflex = Reflection.instance(FakeClass())
-        result = reflex.callMethod("instance_method", 1, 2)
+
+        # Execute Sync Method
+        result = reflex.callMethod("instanceMethod", 1, 2)
         self.assertEqual(result, 3)
 
+        # Execute Async Method
+        result = await reflex.callMethod("asyncMethod")
+        self.assertEqual(result, "This is async")
+
     async def testReflectionInstanceGetMethodSignature(self):
         """Verify getMethodSignature returns the correct method signature."""
         reflex = Reflection.instance(FakeClass())
-        signature = reflex.getMethodSignature("instance_method")
+        signature = reflex.getMethodSignature("instanceMethod")
         self.assertEqual(str(signature), "(x: int, y: int) -> int")
+        signature = reflex.getMethodSignature("__privateMethod")
+        self.assertEqual(str(signature), "() -> str")
 
     async def testReflectionInstanceGetDocstring(self):
         """Check that getDocstring returns the correct class docstring."""
@@ -87,7 +169,8 @@ class TestReflectionInstance(TestCase):
     async def testReflectionInstanceIsInstanceOf(self):
         """Verify isInstanceOf checks inheritance correctly."""
         reflex = Reflection.instance(FakeClass())
-        self.assertTrue(reflex.isInstanceOf(BaseFakeClass))
+        result = reflex.isInstanceOf(BaseFakeClass)
+        self.assertTrue(result)
 
     async def testReflectionInstanceGetSourceCode(self):
         """Check that getSourceCode returns the class source code."""
@@ -118,30 +201,62 @@ class TestReflectionInstance(TestCase):
         reflex = Reflection.instance(FakeClass())
         attr_value = reflex.getAttribute("public_attr")
         self.assertEqual(attr_value, 42)
-
-    async def testReflectionInstanceGetCallableMembers(self):
-        """Verify getCallableMembers returns all callable members."""
-        reflex = Reflection.instance(FakeClass())
-        callable_members = reflex.getCallableMembers()
-        self.assertIn("instance_method", callable_members)
-        self.assertIn("class_method", callable_members)
-        self.assertIn("static_method", callable_members)
+        attr_value = reflex.getAttribute("__private_attr")
+        self.assertEqual(attr_value, "private")
 
     async def testReflectionInstanceSetAttribute(self):
         """Check that setAttribute correctly sets a new attribute."""
-        async def myMacro(cls: FakeClass, num):
-            """Simulate an async function with an async sleep."""
+        reflex = Reflection.instance(FakeClass())
+        reflex.setAttribute("new_attr", 'Orionis')
+        attr_value = reflex.getAttribute("new_attr")
+        self.assertEqual(attr_value, 'Orionis')
+        reflex.setAttribute("__new_private_attr", 'Hidden')
+        attr_value = reflex.getAttribute("__new_private_attr")
+        self.assertEqual(attr_value, 'Hidden')
+
+    async def testReflectionInstanceRemoveAttribute(self):
+        """Ensure removeAttribute correctly removes an attribute."""
+        reflex = Reflection.instance(FakeClass())
+        reflex.setAttribute("temp_attr", 'Temporary')
+        reflex.removeAttribute("temp_attr")
+        self.assertFalse(reflex.hasAttribute("temp_attr"))
+
+    async def testReflectionInstanceSetMacro(self):
+        """Check that setMacro correctly."""
+        async def asyncMacro(cls: FakeClass, num):
             await asyncio.sleep(0.1)
-            return cls.instance_method(10, 12) + num
+            return cls.instanceMethod(10, 12) + num
+        def syncMacro(cls: FakeClass, num):
+            return cls.instanceMethod(10, 12) + num
+        def __privateMacro(cls: FakeClass, num):
+            return cls.instanceMethod(10, 12) + num
 
         reflex = Reflection.instance(FakeClass())
-        reflex.setAttribute("myMacro", myMacro)
 
-        self.assertTrue(reflex.hasAttribute("myMacro"))
+        reflex.setMacro("asyncMacro", asyncMacro)
+        result = await reflex.callMethod("asyncMacro", reflex._instance, 3)
+        self.assertEqual(result, 25)
+
+        reflex.setMacro("syncMacro", syncMacro)
+        result = reflex.callMethod("syncMacro", reflex._instance, 3)
+        self.assertEqual(result, 25)
 
-        result = await reflex.callMethod("myMacro", reflex._instance, 3)
+        reflex.setMacro("__privateMacro", __privateMacro)
+        result = reflex.callMethod("__privateMacro", reflex._instance, 3)
         self.assertEqual(result, 25)
 
+    async def testReflectionInstanceRemoveMacro(self):
+        """Ensure removeMacro correctly removes a macro."""
+        async def asyncMacro(cls: FakeClass, num):
+            await asyncio.sleep(0.1)
+            return cls.instanceMethod(10, 12) + num
+
+        reflex = Reflection.instance(FakeClass())
+        reflex.setMacro("asyncMacro", asyncMacro)
+        reflex.removeMacro("asyncMacro")
+        with self.assertRaises(Exception):
+            await reflex.callMethod("asyncMacro", reflex._instance, 3)
+
     def testReflectionInstanceGetPropertySignature(self):
         """Ensure getPropertySignature returns the correct property signature."""
         signature = Reflection.instance(FakeClass()).getPropertySignature('computed_property')