orionis 0.297.0__py3-none-any.whl → 0.299.0__py3-none-any.whl

orionis/services/introspection/instances/reflection_instance.py

@@ -1,4 +1,5 @@
 import inspect
+import keyword
 from typing import Any, Callable, Dict, List, Optional, Tuple, Type
 from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
@@ -7,11 +8,9 @@ from orionis.services.introspection.dependencies.reflect_dependencies import Ref
 from orionis.services.introspection.exceptions.reflection_attribute_error import ReflectionAttributeError
 from orionis.services.introspection.exceptions.reflection_type_error import ReflectionTypeError
 from orionis.services.introspection.exceptions.reflection_value_error import ReflectionValueError
-from orionis.services.introspection.instances.entities.class_attributes import ClassAttributes
-from orionis.services.introspection.instances.entities.class_method import ClassMethod
-from orionis.services.introspection.instances.entities.class_property import ClassProperty
+from orionis.services.introspection.instances.contracts.reflection_instance import IReflectionInstance
 
-class ReflectionInstance:
+class ReflectionInstance(IReflectionInstance):
 
     def __init__(self, instance: Any) -> None:
         """
@@ -44,6 +43,17 @@ class ReflectionInstance:
             )
         self._instance = instance
 
+    def getInstance(self) -> Any:
+        """
+        Get the instance being reflected upon.
+
+        Returns
+        -------
+        Any
+            The object instance
+        """
+        return self._instance
+
     def getClass(self) -> Type:
         """
         Get the class of the instance.
@@ -86,7 +96,163 @@ class ReflectionInstance:
         str
             The module name
         """
-        return f"{self._instance.__class__}.{self._instance.__class__.__module__}"
+        return f"{self.getModuleName()}.{self.getClassName()}"
+
+    def getDocstring(self) -> Optional[str]:
+        """
+        Get the docstring of the instance's class.
+
+        Returns
+        -------
+        Optional[str]
+            The class docstring, or None if not available
+        """
+        return self._instance.__class__.__doc__
+
+    def getBaseClasses(self) -> Tuple[Type, ...]:
+        """
+        Get the base classes of the instance's class.
+
+        Returns
+        -------
+        Tuple[Type, ...]
+            Tuple of base classes
+        """
+        return self._instance.__class__.__bases__
+
+    def getSourceCode(self) -> Optional[str]:
+        """
+        Get the source code of the instance's class.
+
+        Returns
+        -------
+        Optional[str]
+            The source code if available, None otherwise
+        """
+        try:
+            return inspect.getsource(self._instance.__class__)
+        except (TypeError, OSError):
+            return None
+
+    def getFile(self) -> Optional[str]:
+        """
+        Get the file location where the class is defined.
+
+        Returns
+        -------
+        Optional[str]
+            The file path if available, None otherwise
+        """
+        try:
+            return inspect.getfile(self._instance.__class__)
+        except (TypeError, OSError):
+            return None
+
+    def getAnnotations(self) -> Dict[str, Any]:
+        """
+        Get type annotations of the class.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their type annotations
+        """
+        return self._instance.__class__.__annotations__
+
+    def hasAttribute(self, name: str) -> bool:
+        """
+        Check if the instance has a specific attribute.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name to check
+
+        Returns
+        -------
+        bool
+            True if the attribute exists
+        """
+        return name in self.getAttributes()
+
+    def getAttribute(self, name: str) -> Any:
+        """
+        Get an attribute value by name.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+
+        Returns
+        -------
+        Any
+            The attribute value
+
+        Raises
+        ------
+        AttributeError
+            If the attribute doesn't exist
+        """
+        attrs = self.getAttributes()
+        return attrs.get(name, None)
+
+    def setAttribute(self, name: str, value: Any) -> bool:
+        """
+        Set an attribute value.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+        value : Any
+            The value to set
+
+        Raises
+        ------
+        ReflectionAttributeError
+            If the attribute is read-only
+        """
+        # Ensure the name is a valid attr name with regular expression
+        if not isinstance(name, str) or not name.isidentifier() or keyword.iskeyword(name):
+            raise ReflectionAttributeError(f"Invalid method name '{name}'. Must be a valid Python identifier and not a keyword.")
+
+        # Ensure the value is not callable
+        if callable(value):
+            raise ReflectionAttributeError(f"Cannot set attribute '{name}' to a callable. Use setMacro instead.")
+
+        # Handle private attribute name mangling
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+
+        # Check if the attribute already exists
+        setattr(self._instance, name, value)
+
+        # Return True
+        return True
+
+    def removeAttribute(self, name: str) -> bool:
+        """
+        Remove an attribute from the instance.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name to remove
+
+        Raises
+        ------
+        ReflectionAttributeError
+            If the attribute doesn't exist or is read-only
+        """
+        if self.getAttribute(name) is None:
+            raise ReflectionAttributeError(f"'{self.getClassName()}' object has no attribute '{name}'.")
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+        delattr(self._instance, name)
+        return True
 
     def getAttributes(self) -> Dict[str, Any]:
         """
@@ -188,6 +354,208 @@ class ReflectionInstance:
 
         return dunder
 
+    def getMagicAttributes(self) -> Dict[str, Any]:
+        """
+        Get all magic attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of magic attribute names and their values
+        """
+        return self.getDunderAttributes()
+
+    def hasMethod(self, name: str) -> bool:
+        """
+        Check if the instance has a specific method.
+
+        Parameters
+        ----------
+        name : str
+            The method name to check
+
+        Returns
+        -------
+        bool
+            True if the method exists, False otherwise
+        """
+        # Handle private method name mangling
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+
+        # Check if the method is callable
+        if hasattr(self._instance, name):
+            return callable(getattr(self._instance, name, None))
+
+        # Check if the method is a class method or static method
+        cls = self._instance.__class__
+        if hasattr(cls, name):
+            attr = inspect.getattr_static(cls, name)
+            return isinstance(attr, (classmethod, staticmethod)) and callable(attr.__func__)
+
+        # If not found, return False
+        return False
+
+    def callMethod(self, name: str, *args: Any, **kwargs: Any) -> Any:
+        """
+        Call a method on the instance.
+
+        Parameters
+        ----------
+        name : str
+            Name of the method to call
+        *args : Any
+            Positional arguments for the method
+        **kwargs : Any
+            Keyword arguments for the method
+
+        Returns
+        -------
+        Any
+            The result of the method call
+
+        Raises
+        ------
+        AttributeError
+            If the method does not exist on the instance
+        TypeError
+            If the method is not callable
+        """
+
+        # Hanlde private method name mangling
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+
+        # Try to get the method from the instance
+        method = getattr(self._instance, name, None)
+
+        # If not found, try to get it from the class
+        if method is None:
+            cls = self._instance.__class__
+            method = getattr(cls, name, None)
+
+        # If still not found, raise an error
+        if method is None:
+            raise ReflectionAttributeError(f"Method '{name}' does not exist on '{self.getClassName()}'.")
+
+        # Check if the method is callable
+        if not callable(method):
+            raise ReflectionTypeError(f"'{name}' is not callable on '{self.getClassName()}'.")
+
+        # Check if method is coroutine function
+        if inspect.iscoroutinefunction(method):
+            return Coroutine(method(*args, **kwargs)).run()
+
+        # Call the method with provided arguments
+        return method(*args, **kwargs)
+
+    def setMethod(self, name: str, value: Callable) -> bool:
+        """
+        Set a callable attribute value.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+        value : Callable
+            The callable to set
+
+        Raises
+        ------
+        ReflectionAttributeError
+            If the attribute is not callable or already exists as a method
+        """
+        # Ensure the name is a valid method name with regular expression
+        if not isinstance(name, str) or not name.isidentifier() or keyword.iskeyword(name):
+            raise ReflectionAttributeError(f"Invalid method name '{name}'. Must be a valid Python identifier and not a keyword.")
+
+        # Ensure the value is callable
+        if not callable(value):
+            raise ReflectionAttributeError(f"Cannot set attribute '{name}' to a non-callable value.")
+
+        # Handle private method name mangling
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+
+        # Check if the method already exists
+        if hasattr(self._instance, name):
+            raise ReflectionAttributeError(f"Attribute '{name}' already exists on '{self.getClassName()}'.")
+
+        # Set the method on the instance
+        setattr(self._instance, name, value)
+
+        # Return True
+        return True
+
+    def removeMethod(self, name: str) -> None:
+        """
+        Remove a method from the instance.
+
+        Parameters
+        ----------
+        name : str
+            The method name to remove
+
+        Raises
+        ------
+        ReflectionAttributeError
+            If the method does not exist or is not callable
+        """
+        if not self.hasMethod(name):
+            raise ReflectionAttributeError(f"Method '{name}' does not exist on '{self.getClassName()}'.")
+        delattr(self._instance, name)
+
+    def getMethodSignature(self, name: str) -> inspect.Signature:
+        """
+        Get the signature of a method.
+
+        Parameters
+        ----------
+        name : str
+            Name of the method
+
+        Returns
+        -------
+        inspect.Signature
+            The method signature
+        """
+
+        # Handle private method name mangling
+        if name.startswith("__") and not name.endswith("__"):
+            name = f"_{self.getClassName()}{name}"
+
+        # Check if the method exists and is callable
+        method = getattr(self._instance, name)
+        if callable(method):
+            return inspect.signature(method)
+
+        # If the method is not callable, raise an error
+        raise ReflectionAttributeError(f"Method '{name}' is not callable on '{self.getClassName()}'.")
+
+    def getMethods(self) -> List[str]:
+        """
+        Get all method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of method names
+        """
+        return [
+            *self.getPublicMethods(),
+            *self.getProtectedMethods(),
+            *self.getPrivateMethods(),
+            *self.getPublicClassMethods(),
+            *self.getProtectedClassMethods(),
+            *self.getPrivateClassMethods(),
+            *self.getPublicStaticMethods(),
+            *self.getProtectedStaticMethods(),
+            *self.getPrivateStaticMethods(),
+        ]
+
     def getPublicMethods(self) -> List[str]:
         """
         Get all public method names of the instance.
@@ -436,45 +804,78 @@ class ReflectionInstance:
         # Return the list of public asynchronous class method names
         return public_class_async_methods
 
+    def getProtectedClassMethods(self) -> List[str]:
+        """
+        Get all protected class method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of protected class method names
+        """
+        cls = self._instance.__class__
+        class_methods = []
 
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
+            # Check if the attribute is a class method
+            if isinstance(attr, classmethod):
 
+                # Check is a protected class method
+                if name.startswith(f"_") and not name.startswith("__") and not name.startswith(f"_{self.getClassName()}"):
+                    class_methods.append(name)
 
+        # Return the list of public class method
+        return class_methods
 
+    def getProtectedClassSyncMethods(self) -> List[str]:
+        """
+        Get all protected synchronous class method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of protected synchronous class method names
+        """
+        class_name = self.getClassName()
+        cls = self._instance.__class__
+        protected_class_sync_methods = []
 
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
+            # Check if the attribute is a class method
+            if isinstance(attr, classmethod):
 
+                # Get the underlying function
+                func = attr.__func__
 
+                # Check if it's NOT a coroutine function (i.e., synchronous)
+                if not inspect.iscoroutinefunction(func) and name.startswith(f"_") and not name.startswith(f"_{class_name}"):
+                    protected_class_sync_methods.append(str(name).replace(f"_{class_name}", ""))
 
+        # Return the list of protected class method names
+        return protected_class_sync_methods
 
-
-
-
-
-
-
-
-
-
-
-
-
-    def getProtectedClassMethods(self) -> List[str]:
+    def getProtectedClassAsyncMethods(self) -> List[str]:
         """
-        Get all protected class method names of the instance.
+        Get all protected asynchronous class method names of the instance.
 
         Returns
         -------
         List[str]
-            List of protected class method names
+            List of protected asynchronous class method names
         """
         class_name = self.getClassName()
         cls = self._instance.__class__
-        protected_class_methods = []
+        protected_class_async_methods = []
 
         # Iterate over all attributes of the class
         for name in dir(cls):
@@ -488,12 +889,12 @@ class ReflectionInstance:
                 # Get the underlying function
                 func = attr.__func__
 
-                # Check if it's NOT a coroutine function (i.e., synchronous)
-                if not inspect.iscoroutinefunction(func) and name.startswith(f"_") and not name.startswith("__") and not name.startswith(f"_{class_name}"):
-                    protected_class_methods.append(str(name).replace(f"_{class_name}", ""))
+                # Check if it's a coroutine function (i.e., asynchronous)
+                if inspect.iscoroutinefunction(func) and name.startswith(f"_") and not name.startswith(f"_{class_name}"):
+                    protected_class_async_methods.append(str(name).replace(f"_{class_name}", ""))
 
-        # Return the list of protected class method names
-        return protected_class_methods
+        # Return the list of protected asynchronous class method names
+        return protected_class_async_methods
 
     def getPrivateClassMethods(self) -> List[str]:
         """
@@ -520,41 +921,25 @@ class ReflectionInstance:
                 # Get the underlying function
                 func = attr.__func__
 
-                # Check if it's NOT a coroutine function (i.e., synchronous)
-                if not inspect.iscoroutinefunction(func) and name.startswith(f"_{class_name}"):
+                # Check if a private class method
+                if name.startswith(f"_{class_name}"):
                     private_class_methods.append(str(name).replace(f"_{class_name}", ""))
 
         # Return the list of protected class method names
         return private_class_methods
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    def getClassSyncMethods(self) -> List[str]:
+    def getPrivateClassSyncMethods(self) -> List[str]:
         """
-        Get all synchronous class method names of the instance.
+        Get all private synchronous class method names of the instance.
 
         Returns
         -------
         List[str]
-            List of synchronous class method names
+            List of private synchronous class method names
         """
         class_name = self.getClassName()
         cls = self._instance.__class__
-        class_sync_methods = []
+        private_class_sync_methods = []
 
         # Iterate over all attributes of the class
         for name in dir(cls):
@@ -569,24 +954,24 @@ class ReflectionInstance:
                 func = attr.__func__
 
                 # Check if it's NOT a coroutine function (i.e., synchronous)
-                if not inspect.iscoroutinefunction(func):
-                    class_sync_methods.append(str(name).replace(f"_{class_name}", ""))
+                if not inspect.iscoroutinefunction(func) and name.startswith(f"_{class_name}"):
+                    private_class_sync_methods.append(str(name).replace(f"_{class_name}", ""))
 
-        # Return the list of synchronous class method names
-        return class_sync_methods
+        # Return the list of private synchronous class method names
+        return private_class_sync_methods
 
-    def getClassAsyncMethods(self) -> List[str]:
+    def getPrivateClassAsyncMethods(self) -> List[str]:
         """
-        Get all asynchronous class method names of the instance.
+        Get all private asynchronous class method names of the instance.
 
         Returns
         -------
         List[str]
-            List of asynchronous class method names
+            List of private asynchronous class method names
         """
         class_name = self.getClassName()
         cls = self._instance.__class__
-        class_async_methods = []
+        private_class_async_methods = []
 
         # Iterate over all attributes of the class
         for name in dir(cls):
@@ -601,104 +986,219 @@ class ReflectionInstance:
                 func = attr.__func__
 
                 # Check if it's a coroutine function (i.e., asynchronous)
-                if inspect.iscoroutinefunction(func):
-                    class_async_methods.append(str(name).replace(f"_{class_name}", ""))
+                if inspect.iscoroutinefunction(func) and name.startswith(f"_{class_name}"):
+                    private_class_async_methods.append(str(name).replace(f"_{class_name}", ""))
+
+        # Return the list of private asynchronous class method names
+        return private_class_async_methods
 
-        # Return the list of asynchronous class method names
-        return class_async_methods
+    def getPublicStaticMethods(self) -> List[str]:
+        """
+        Get public static method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of static method names
+        """
+        cls = self._instance.__class__
+        static_methods = []
+        for name in dir(cls):
+            attr = inspect.getattr_static(cls, name)
+            if isinstance(attr, staticmethod) and not name.startswith(f"_"):
+                static_methods.append(name)
+        return static_methods
 
+    def getPublicStaticSyncMethods(self) -> List[str]:
+        """
+        Get all public synchronous static method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of public synchronous static method names
+        """
+        class_name = self.getClassName()
+        cls = self._instance.__class__
+        public_static_sync_methods = []
 
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
+            # Check if the attribute is a static method
+            if isinstance(attr, staticmethod):
 
+                # Get the underlying function
+                func = attr.__func__
 
+                # Check if it's NOT a coroutine function (i.e., synchronous)
+                if not inspect.iscoroutinefunction(func) and not name.startswith(f"_"):
+                    public_static_sync_methods.append(str(name).replace(f"_{class_name}", ""))
 
+        # Return the list of public synchronous static method names
+        return public_static_sync_methods
 
+    def getPublicStaticAsyncMethods(self) -> List[str]:
+        """
+        Get all public asynchronous static method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of public asynchronous static method names
+        """
+        class_name = self.getClassName()
+        cls = self._instance.__class__
+        public_static_async_methods = []
 
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
+            # Check if the attribute is a static method
+            if isinstance(attr, staticmethod):
 
+                # Get the underlying function
+                func = attr.__func__
 
+                # Check if it's a coroutine function (i.e., asynchronous)
+                if inspect.iscoroutinefunction(func) and not name.startswith(f"_"):
+                    public_static_async_methods.append(str(name).replace(f"_{class_name}", ""))
 
+        # Return the list of public asynchronous static method names
+        return public_static_async_methods
 
+    def getProtectedStaticMethods(self) -> List[str]:
+        """
+        Get all protected static method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of protected static method names
+        """
+        cls = self._instance.__class__
+        protected_static_methods = []
 
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
+            # Check if the attribute is a static method
+            if isinstance(attr, staticmethod) and name.startswith(f"_") and not name.startswith("__") and not name.startswith(f"_{self.getClassName()}"):
+                protected_static_methods.append(name)
 
+        return protected_static_methods
 
+    def getProtectedStaticSyncMethods(self) -> List[str]:
+        """
+        Get all protected synchronous static method names of the instance.
 
+        Returns
+        -------
+        List[str]
+            List of protected synchronous static method names
+        """
+        class_name = self.getClassName()
+        cls = self._instance.__class__
+        protected_static_sync_methods = []
 
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
+            # Check if the attribute is a static method
+            if isinstance(attr, staticmethod):
 
+                # Get the underlying function
+                func = attr.__func__
 
+                # Check if it's NOT a coroutine function (i.e., synchronous)
+                if not inspect.iscoroutinefunction(func) and name.startswith(f"_") and not name.startswith(f"_{class_name}"):
+                    protected_static_sync_methods.append(str(name).replace(f"_{class_name}", ""))
 
+        return protected_static_sync_methods
 
-    def getDunderMethods(self) -> List[str]:
+    def getProtectedStaticAsyncMethods(self) -> List[str]:
         """
-        Get all dunder (double underscore) method names of the instance.
+        Get all protected asynchronous static method names of the instance.
 
         Returns
         -------
         List[str]
-            List of dunder method names
+            List of protected asynchronous static method names
         """
-        dunder_methods = []
+        class_name = self.getClassName()
+        cls = self._instance.__class__
+        protected_static_async_methods = []
 
-        # Collect dunder methods (starting and ending with double underscores)
-        for name in dir(self._instance):
-            if name.startswith("__") and name.endswith("__"):
-                dunder_methods.append(name)
+        # Iterate over all attributes of the class
+        for name in dir(cls):
 
-        return dunder_methods
+            # Get the attribute using getattr_static to avoid triggering property getters
+            attr = inspect.getattr_static(cls, name)
 
-    def getMagicMethods(self) -> List[str]:
-        """
-        Get all magic method names of the instance.
+            # Check if the attribute is a static method
+            if isinstance(attr, staticmethod):
 
-        Returns
-        -------
-        List[str]
-            List of magic method names
-        """
-        return self.getDunderMethods()
+                # Get the underlying function
+                func = attr.__func__
+
+                # Check if it's a coroutine function (i.e., asynchronous)
+                if inspect.iscoroutinefunction(func) and name.startswith(f"_") and not name.startswith(f"_{class_name}"):
+                    protected_static_async_methods.append(str(name).replace(f"_{class_name}", ""))
 
-    
+        return protected_static_async_methods
 
-    def getStaticMethods(self) -> List[str]:
+    def getPrivateStaticMethods(self) -> List[str]:
         """
-        Get all static method names of the instance.
+        Get all private static method names of the instance.
 
         Returns
         -------
         List[str]
-            List of static method names
+            List of private static method names
         """
         class_name = self.getClassName()
         cls = self._instance.__class__
-        static_methods = []
+        private_static_methods = []
+
+        # Iterate over all attributes of the class
         for name in dir(cls):
+
+            # Get the attribute using getattr_static to avoid triggering property getters
             attr = inspect.getattr_static(cls, name)
+
+            # Check if the attribute is a static method
             if isinstance(attr, staticmethod):
-                static_methods.append(str(name).replace(f"_{class_name}", ""))
-        return static_methods
 
-    def getStaticSyncMethods(self) -> List[str]:
+                # Check if a private static method
+                if name.startswith(f"_{class_name}"):
+                    private_static_methods.append(str(name).replace(f"_{class_name}", ""))
+
+        return private_static_methods
+
+    def getPrivateStaticSyncMethods(self) -> List[str]:
         """
-        Get all synchronous static method names of the instance.
+        Get all private synchronous static method names of the instance.
 
         Returns
         -------
         List[str]
-            List of synchronous static method names
+            List of private synchronous static method names
         """
         class_name = self.getClassName()
         cls = self._instance.__class__
-        static_sync_methods = []
+        private_static_sync_methods = []
 
         # Iterate over all attributes of the class
         for name in dir(cls):
@@ -713,24 +1213,23 @@ class ReflectionInstance:
                 func = attr.__func__
 
                 # Check if it's NOT a coroutine function (i.e., synchronous)
-                if not inspect.iscoroutinefunction(func):
-                    static_sync_methods.append(str(name).replace(f"_{class_name}", ""))
+                if not inspect.iscoroutinefunction(func) and name.startswith(f"_{class_name}"):
+                    private_static_sync_methods.append(str(name).replace(f"_{class_name}", ""))
 
-        # Return the list of synchronous static method names
-        return static_sync_methods
+        return private_static_sync_methods
 
-    def getStaticAsyncMethods(self) -> List[str]:
+    def getPrivateStaticAsyncMethods(self) -> List[str]:
         """
-        Get all asynchronous static method names of the instance.
+        Get all private asynchronous static method names of the instance.
 
         Returns
         -------
         List[str]
-            List of asynchronous static method names
+            List of private asynchronous static method names
         """
         class_name = self.getClassName()
         cls = self._instance.__class__
-        static_async_methods = []
+        private_static_async_methods = []
 
         # Iterate over all attributes of the class
         for name in dir(cls):
@@ -745,556 +1244,200 @@ class ReflectionInstance:
                 func = attr.__func__
 
                 # Check if it's a coroutine function (i.e., asynchronous)
-                if inspect.iscoroutinefunction(func):
-                    static_async_methods.append(str(name).replace(f"_{class_name}", ""))
+                if inspect.iscoroutinefunction(func) and name.startswith(f"_{class_name}"):
+                    private_static_async_methods.append(str(name).replace(f"_{class_name}", ""))
 
-        # Return the list of asynchronous static method names
-        return static_async_methods
+        return private_static_async_methods
 
-    # def getMethodDocstring(self, method_name: str) -> Optional[str]:
-    #     """
-    #     Get the docstring of a method.
+    def getDunderMethods(self) -> List[str]:
+        """
+        Get all dunder (double underscore) method names of the instance.
 
-    #     Parameters
-    #     ----------
-    #     method_name : str
-    #         Name of the method
+        Returns
+        -------
+        List[str]
+            List of dunder method names
+        """
+        dunder_methods = []
 
-    #     Returns
-    #     -------
-    #     Optional[str]
-    #         The docstring of the method, or None if not available
-    #     """
-    #     # Handle private method name mangling
-    #     if method_name in self.getPrivateMethods() or method_name in self.getClass
-    #         method_name = f"_{self.getClassName()}{method_name}"
-        
-    #     print(f"Getting docstring for method: {method_name} in class: {self.getPrivateMethods()}")
+        # Collect dunder methods (starting and ending with double underscores)
+        for name in dir(self._instance):
+            if name.startswith("__") and name.endswith("__"):
+                dunder_methods.append(name)
 
-    #     # Try to get the method from the instance first
-    #     method = getattr(self._instance, method_name, None)
-    #     if method is None:
-    #         # Try to get the method from the class if not found on the instance
-    #         method = getattr(self._instance.__class__, method_name, None)
-    #         if method is None:
-    #             return None
+        return dunder_methods
 
-    #     # If it's a staticmethod or classmethod, get the underlying function
-    #     if isinstance(method, (staticmethod, classmethod)):
-    #         method = method.__func__
+    def getMagicMethods(self) -> List[str]:
+        """
+        Get all magic method names of the instance.
 
-    #     # Return the docstring if available
-    #     return getattr(method, "__doc__", None) or ""
+        Returns
+        -------
+        List[str]
+            List of magic method names
+        """
+        return self.getDunderMethods()
 
-    # def getMethodSignature(self, method_name: str) -> inspect.Signature:
-    #     """
-    #     Get the signature of a method.
+    def getProperties(self) -> Dict:
+        """
+        Get all properties of the instance.
 
-    #     Parameters
-    #     ----------
-    #     method_name : str
-    #         Name of the method
+        Returns
+        -------
+        List[str]
+            List of property names
+        """
 
-    #     Returns
-    #     -------
-    #     inspect.Signature
-    #         The method signature
+        properties = {}
+        for name, prop in self._instance.__class__.__dict__.items():
+            if isinstance(prop, property):
+                name = name.replace(f"_{self.getClassName()}", "")
+                properties[name] = getattr(self._instance, name, None)
+        return properties
 
-    #     Raises
-    #     ------
-    #     ReflectionAttributeError
-    #         If the method does not exist on the instance
-    #     """
-    #     if method_name in self.getPrivateMethods():
-    #         method_name = f"_{self.getClassName()}{method_name}"
+    def getPublicProperties(self) -> Dict:
+        """
+        Get all public properties of the instance.
 
-    #     method = getattr(self._instance, method_name, None)
-    #     if method is None or not callable(method):
-    #         raise ReflectionAttributeError(f"Method '{method_name}' not found in '{self.getClassName()}'.")
+        Returns
+        -------
+        Dict[str]
+            Dictionary of public property names and their values
+        """
+        properties = {}
+        for name, prop in self._instance.__class__.__dict__.items():
+            if isinstance(prop, property):
+                if not name.startswith(f"_"):
+                    properties[name] = getattr(self._instance, name, None)
+        return properties
 
-    #     return inspect.signature(method)
+    def getProtectedProperties(self) -> Dict:
+        """
+        Get all protected properties of the instance.
 
+        Returns
+        -------
+        Dict[str]
+            Dictionary of protected property names and their values
+        """
+        properties = {}
+        for name, prop in self._instance.__class__.__dict__.items():
+            if isinstance(prop, property):
+                if name.startswith(f"_") and not name.startswith("__") and not name.startswith(f"_{self.getClassName()}"):
+                    properties[name] = getattr(self._instance, name, None)
+        return properties
 
+    def getPrivateProperties(self) -> Dict:
+        """
+        Get all private properties of the instance.
 
+        Returns
+        -------
+        Dict[str]
+            Dictionary of private property names and their values
+        """
+        properties = {}
+        for name, prop in self._instance.__class__.__dict__.items():
+            if isinstance(prop, property):
+                if name.startswith(f"_{self.getClassName()}") and not name.startswith("__"):
+                    properties[name.replace(f"_{self.getClassName()}", "")] = getattr(self._instance, name, None)
+        return properties
 
+    def getPropierty(self, name: str) -> Any:
+        """
+        Get a specific property of the instance.
 
+        Parameters
+        ----------
+        name : str
+            The name of the property to retrieve
 
+        Returns
+        -------
+        ClassProperty
+            The value of the specified property
 
+        Raises
+        ------
+        ReflectionAttributeError
+            If the property does not exist or is not accessible
+        """
+        # Check if the property name is valid
+        if name in self.getProperties():
 
+            # Handle private property name mangling
+            if name.startswith("__") and not name.endswith("__"):
+                class_name = self.getClassName()
+                name = f"_{class_name}{name}"
 
+            # Return the property value from the instance
+            return getattr(self._instance, name, None)
 
+        # If the property does not exist, raise an error
+        raise ReflectionAttributeError(f"Property '{name}' does not exist on '{self.getClassName()}'.")
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    def getProperties(self) -> Dict[str, ClassProperty]:
-        """
-        Get all properties of the instance.
-
-        Returns
-        -------
-        List[str]
-            List of property names
-        """
-
-        properties = {}
-        for name, prop in self._instance.__class__.__dict__.items():
-            if isinstance(prop, property):
-                properties[name] = ClassProperty(
-                    name=name,
-                    value=getattr(self._instance, name, None),
-                    signature=inspect.signature(prop.fget) if prop.fget else None,
-                    doc=prop.__doc__ or ""
-                )
-        return properties
-
-    def getPropertyNames(self) -> List[str]:
-        """
-        Get all property names of the instance.
-
-        Returns
-        -------
-        List[str]
-            List of property names
-        """
-        return self.getProperties().keys()
-
-    def getProperty(self, property_name: str) -> Any:
-        """
-        Get the value of a property.
-
-        Parameters
-        ----------
-        property_name : str
-            Name of the property
-
-        Returns
-        -------
-        Any
-            The value of the property
-
-        Raises
-        ------
-        AttributeError
-            If the property doesn't exist or is not a property
-        """
-        all_prop = self.getProperties()
-        if property_name not in all_prop:
-            raise ReflectionValueError(f"Property '{property_name}' not found.")
-        return all_prop[property_name].value
-
-    def getPropertySignature(self, property_name: str) -> inspect.Signature:
+    def getPropertySignature(self, name: str) -> inspect.Signature:
         """
         Get the signature of a property.
 
         Parameters
         ----------
-        property_name : str
+        name : str
             Name of the property
 
         Returns
         -------
         inspect.Signature
             The property signature
-
-        Raises
-        ------
-        AttributeError
-            If the property doesn't exist or is not a property
         """
-        all_prop = self.getProperties()
-        if property_name not in all_prop:
-            raise ReflectionValueError(f"Property '{property_name}' not found.")
-        return all_prop[property_name].signature
+        # Handle private property name mangling
+        original_name = name
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+
+        # Check if the property exists
+        prop = getattr(self._instance.__class__, name, None)
+        if isinstance(prop, property):
+            return inspect.signature(prop.fget)
+
+        # If the property does not exist, raise an error
+        raise ReflectionAttributeError(f"Property '{original_name}' does not exist on '{self.getClassName()}'.")
 
-    def getPropertyDoc(self, property_name: str) -> str:
+    def getPropiertyDocstring(self, name: str) -> str:
         """
         Get the docstring of a property.
 
         Parameters
         ----------
-        property_name : str
+        name : str
             Name of the property
 
         Returns
         -------
         str
             The docstring of the property
-
-        Raises
-        ------
-        AttributeError
-            If the property doesn't exist or is not a property
-        """
-        all_prop = self.getProperties()
-        if property_name not in all_prop:
-            raise ReflectionValueError(f"Property '{property_name}' not found.")
-        return all_prop[property_name].doc
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    def callMethod(self, method_name: str, *args: Any, **kwargs: Any) -> Any:
-        """
-        Call a method on the instance.
-
-        Parameters
-        ----------
-        method_name : str
-            Name of the method to call
-        *args : Any
-            Positional arguments for the method
-        **kwargs : Any
-            Keyword arguments for the method
-
-        Returns
-        -------
-        Any
-            The result of the method call
-
-        Raises
-        ------
-        AttributeError
-            If the method does not exist on the instance
-        TypeError
-            If the method is not callable
         """
+        # Handle private property name mangling
+        original_name = name
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
 
-        if method_name in self.getPrivateMethods():
-            method_name = f"_{self.getClassName()}{method_name}"
-
-        method = getattr(self._instance, method_name, None)
-
-        if method is None:
-            raise AttributeError(f"'{self.getClassName()}' object has no method '{method_name}'.")
-        if not callable(method):
-            raise TypeError(f"'{method_name}' is not callable on '{self.getClassName()}'.")
-
-        if inspect.iscoroutinefunction(method):
-            return Coroutine(method(*args, **kwargs)).run()
+        # Check if the property exists
+        prop = getattr(self._instance.__class__, name, None)
+        if isinstance(prop, property):
+            return prop.fget.__doc__ or ""
 
-        return method(*args, **kwargs)
-
-    def getMethodSignature(self, method_name: str) -> inspect.Signature:
-        """
-        Get the signature of a method.
-
-        Parameters
-        ----------
-        method_name : str
-            Name of the method
-
-        Returns
-        -------
-        inspect.Signature
-            The method signature
-        """
-        if method_name in self.getPrivateMethods():
-            method_name = f"_{self.getClassName()}{method_name}"
-
-        method = getattr(self._instance, method_name)
-        if callable(method):
-            return inspect.signature(method)
-
-    def getDocstring(self) -> Optional[str]:
-        """
-        Get the docstring of the instance's class.
-
-        Returns
-        -------
-        Optional[str]
-            The class docstring, or None if not available
-        """
-        return self._instance.__class__.__doc__
-
-    def getBaseClasses(self) -> Tuple[Type, ...]:
-        """
-        Get the base classes of the instance's class.
-
-        Returns
-        -------
-        Tuple[Type, ...]
-            Tuple of base classes
-        """
-        return self._instance.__class__.__bases__
-
-    def isInstanceOf(self, cls: Type) -> bool:
-        """
-        Check if the instance is of a specific class.
-
-        Parameters
-        ----------
-        cls : Type
-            The class to check against
-
-        Returns
-        -------
-        bool
-            True if the instance is of the specified class
-        """
-        return isinstance(self._instance, cls)
-
-    def getSourceCode(self) -> Optional[str]:
-        """
-        Get the source code of the instance's class.
-
-        Returns
-        -------
-        Optional[str]
-            The source code if available, None otherwise
-        """
-        try:
-            return inspect.getsource(self._instance.__class__)
-        except (TypeError, OSError):
-            return None
-
-    def getFileLocation(self) -> Optional[str]:
-        """
-        Get the file location where the class is defined.
-
-        Returns
-        -------
-        Optional[str]
-            The file path if available, None otherwise
-        """
-        try:
-            return inspect.getfile(self._instance.__class__)
-        except (TypeError, OSError):
-            return None
-
-    def getAnnotations(self) -> Dict[str, Any]:
-        """
-        Get type annotations of the class.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Dictionary of attribute names and their type annotations
-        """
-        return self._instance.__class__.__annotations__
-
-    def hasAttribute(self, name: str) -> bool:
-        """
-        Check if the instance has a specific attribute.
-
-        Parameters
-        ----------
-        name : str
-            The attribute name to check
-
-        Returns
-        -------
-        bool
-            True if the attribute exists
-        """
-        return hasattr(self._instance, name)
-
-    def getAttribute(self, name: str) -> Any:
-        """
-        Get an attribute value by name.
-
-        Parameters
-        ----------
-        name : str
-            The attribute name
-
-        Returns
-        -------
-        Any
-            The attribute value
-
-        Raises
-        ------
-        AttributeError
-            If the attribute doesn't exist
-        """
-        attrs = self.getAttributes()
-        return attrs.get(name, getattr(self._instance, name, None))
-
-    def setAttribute(self, name: str, value: Any) -> None:
-        """
-        Set an attribute value.
-
-        Parameters
-        ----------
-        name : str
-            The attribute name
-        value : Any
-            The value to set
-
-        Raises
-        ------
-        AttributeError
-            If the attribute is read-only
-        """
-        if callable(value):
-            raise AttributeError(f"Cannot set attribute '{name}' to a callable. Use setMacro instead.")
-        setattr(self._instance, name, value)
-
-    def removeAttribute(self, name: str) -> None:
-        """
-        Remove an attribute from the instance.
-
-        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 removeMacro(self, name: str) -> None:
-        """
-        Remove a callable attribute from the instance.
-
-        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)
+        # If the property does not exist, raise an error
+        raise ReflectionAttributeError(f"Property '{original_name}' does not exist on '{self.getClassName()}'.")
 
     def getConstructorDependencies(self) -> ClassDependency:
         """
         Get the resolved and unresolved dependencies from the constructor of the instance's class.
 
+
+
         Returns
         -------
         ClassDependency
@@ -1320,4 +1463,15 @@ class ReflectionInstance:
             - resolved: Dictionary of resolved dependencies with their names and values.
             - unresolved: List of unresolved dependencies (parameter names without default values or annotations).
         """
-        return ReflectDependencies(self._instance).getMethodDependencies(method_name)
+
+        # Ensure the method name is a valid identifier
+        if not self.hasMethod(method_name):
+            raise ReflectionAttributeError(f"Method '{method_name}' does not exist on '{self.getClassName()}'.")
+
+        # Handle private method name mangling
+        if method_name.startswith("__") and not method_name.endswith("__"):
+            class_name = self.getClassName()
+            method_name = f"_{class_name}{method_name}"
+
+        # Use ReflectDependencies to get method dependencies
+        return ReflectDependencies(self._instance).getMethodDependencies(method_name)