orionis 0.611.0__tar.gz → 0.612.0__tar.gz

{orionis-0.611.0/orionis.egg-info → orionis-0.612.0}/PKG-INFO

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

{orionis-0.611.0 → orionis-0.612.0}/orionis/metadata/framework.py

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

{orionis-0.611.0 → orionis-0.612.0}/orionis/services/introspection/concretes/reflection.py

@@ -245,24 +245,56 @@ class ReflectionConcrete(IReflectionConcrete):
         """
         return self._concrete.__bases__
 
-    def getSourceCode(self) -> str:
+    def getSourceCode(self, method: str = None) -> str | None:
         """
-        Get the source code of the reflected class.
+        Retrieve the source code for the reflected class or a specific method.
+
+        Parameters
+        ----------
+        method : str, optional
+            The name of the method whose source code should be retrieved. If not provided,
+            the source code of the entire class is returned. If the method name refers to a
+            private method, Python name mangling is handled automatically.
 
         Returns
         -------
-        str
-            The complete source code of the class definition.
+        str or None
+            The source code as a string if available. Returns None if the source code cannot
+            be found (e.g., for built-in or dynamically generated classes/methods), or if the
+            specified method does not exist.
 
-        Raises
-        ------
-        ReflectionValueError
-            If the source code cannot be retrieved (e.g., built-in classes).
+        Notes
+        -----
+        - If `method` is specified and refers to a private method, name mangling is handled automatically.
+        - If the source code cannot be found (e.g., for built-in or dynamically generated classes/methods), None is returned.
+        - If the specified method does not exist in the class, None is returned.
         """
+
         try:
-            return inspect.getsource(self._concrete)
-        except OSError as e:
-            raise ReflectionValueError(f"Could not retrieve source code for '{self._concrete.__name__}': {e}")
+
+            # Return the source code of the entire class
+            if not method:
+                return inspect.getsource(self._concrete)
+
+            # Handle private method name mangling for methods starting with double underscore
+            else:
+
+                # Handle private method name mangling
+                if method.startswith("__") and not method.endswith("__"):
+                    class_name = self.getClassName()
+                    method = f"_{class_name}{method}"
+
+                # Check if the method exists in the class
+                if not self.hasMethod(method):
+                    return None
+
+                # Return the source code of the specified method
+                return inspect.getsource(getattr(self._concrete, method))
+
+        except (TypeError, OSError):
+
+            # Return None if the source code cannot be retrieved (e.g., built-in or dynamic)
+            return None
 
     def getFile(self) -> str:
         """
@@ -438,25 +470,36 @@ class ReflectionConcrete(IReflectionConcrete):
 
     def getAttributes(self) -> dict:
         """
-        Get all class attributes regardless of visibility.
+        Retrieve all class attributes across all visibility levels.
 
-        Combines public, protected, private, and dunder attributes into a
-        single dictionary for comprehensive attribute access.
+        This method aggregates and returns a dictionary containing all attributes
+        defined on the reflected class, including public, protected, private (with
+        name mangling resolved), and dunder (magic) attributes. Callable members,
+        static methods, class methods, and properties are excluded from the result.
 
         Returns
         -------
         dict
-            A dictionary mapping attribute names to their values, including
-            all visibility levels (public, protected, private, dunder).
+            A dictionary mapping attribute names (as strings) to their corresponding
+            values. The dictionary includes attributes of all visibility levels:
+            public, protected, private (with name mangling removed), and dunder
+            attributes, but excludes methods and properties. The result is cached
+            after the first call for performance.
         """
 
-        # Combine all attribute types into a single dictionary
-        return {
-            **self.getPublicAttributes(),
-            **self.getProtectedAttributes(),
-            **self.getPrivateAttributes(),
-            **self.getDunderAttributes()
-        }
+        # Use cache to avoid recomputation on subsequent calls
+        if not hasattr(self, "_ReflectionConcrete__cacheGetAttributes"):
+
+            # Merge all attribute dictionaries from different visibility levels
+            self.__cacheGetAttributes = {
+                **self.getPublicAttributes(),
+                **self.getProtectedAttributes(),
+                **self.getPrivateAttributes(),
+                **self.getDunderAttributes()
+            }
+
+        # Return the cached dictionary of all attributes
+        return self.__cacheGetAttributes
 
     def getPublicAttributes(self) -> dict:
         """
@@ -769,27 +812,36 @@ class ReflectionConcrete(IReflectionConcrete):
 
     def getMethods(self) -> List[str]:
         """
-        Get all method names from the reflected class.
+        Retrieve all method names defined in the reflected class, including instance, class, and static methods.
 
-        Combines all types of methods including instance methods, class methods,
-        and static methods with different visibility levels.
+        This method aggregates method names from all visibility levels (public, protected, private) and method types
+        (instance, class, static). The result is cached after the first call to improve performance on subsequent calls.
 
         Returns
         -------
         List[str]
-            A comprehensive list of all method names in the class.
-        """
-        return [
-            *self.getPublicMethods(),
-            *self.getProtectedMethods(),
-            *self.getPrivateMethods(),
-            *self.getPublicClassMethods(),
-            *self.getProtectedClassMethods(),
-            *self.getPrivateClassMethods(),
-            *self.getPublicStaticMethods(),
-            *self.getProtectedStaticMethods(),
-            *self.getPrivateStaticMethods(),
-        ]
+            A list containing the names of all methods (instance, class, and static) defined in the class,
+            including public, protected, and private methods. The list is cached for efficiency.
+        """
+
+        # Check if the method names have already been cached
+        if not hasattr(self, "_ReflectionConcrete__cacheGetMethods"):
+
+            # Aggregate all method names from different categories and cache the result
+            self.__cacheGetMethods = [
+                *self.getPublicMethods(),
+                *self.getProtectedMethods(),
+                *self.getPrivateMethods(),
+                *self.getPublicClassMethods(),
+                *self.getProtectedClassMethods(),
+                *self.getPrivateClassMethods(),
+                *self.getPublicStaticMethods(),
+                *self.getProtectedStaticMethods(),
+                *self.getPrivateStaticMethods(),
+            ]
+
+        # Return the cached list of method names
+        return self.__cacheGetMethods
 
     def getPublicMethods(self) -> list:
         """

{orionis-0.611.0 → orionis-0.612.0}/orionis/services/introspection/instances/reflection.py

@@ -189,18 +189,52 @@ class ReflectionInstance(IReflectionInstance):
         """
         return self._instance.__class__.__bases__
 
-    def getSourceCode(self) -> Optional[str]:
+    def getSourceCode(self, method: str = None) -> Optional[str]:
         """
-        Get the source code of the instance's class.
+        Retrieve the source code of the instance's class or a specific method.
+
+        Parameters
+        ----------
+        method : str, optional
+            The name of the method whose source code should be retrieved. If not provided,
+            the source code of the entire class is returned.
 
         Returns
         -------
         Optional[str]
-            The source code if available, None otherwise
+            The source code as a string if available; otherwise, None.
+
+        Raises
+        ------
+        None
+            This method does not raise exceptions; it returns None if the source code cannot be retrieved.
+
+        Notes
+        -----
+        - If `method` is specified and refers to a private method, name mangling is handled automatically.
+        - If the source code cannot be found (e.g., for built-in or dynamically generated classes/methods), None is returned.
         """
         try:
-            return inspect.getsource(self._instance.__class__)
+            if not method:
+                # Return the source code of the class
+                return inspect.getsource(self._instance.__class__)
+            else:
+
+                # Handle private method name mangling
+                if method.startswith("__") and not method.endswith("__"):
+                    class_name = self.getClassName()
+                    method = f"_{class_name}{method}"
+
+                # Check if the method exists
+                if not self.hasMethod(method):
+                    return None
+
+                # Return the source code of the specified method
+                return inspect.getsource(getattr(self._instance.__class__, method))
+
         except (TypeError, OSError):
+
+            # Return None if the source code cannot be retrieved
             return None
 
     def getFile(self) -> Optional[str]:
@@ -340,19 +374,38 @@ class ReflectionInstance(IReflectionInstance):
 
     def getAttributes(self) -> Dict[str, Any]:
         """
-        Get all attributes of the instance, including public, private, protected, and dunder attributes.
+        Retrieve all attributes of the instance, including public, protected, private, and dunder (magic) attributes.
+
+        This method aggregates attributes from all visibility levels by combining the results of
+        `getPublicAttributes`, `getProtectedAttributes`, `getPrivateAttributes`, and `getDunderAttributes`.
+        The result is cached for subsequent calls to improve performance.
 
         Returns
         -------
         Dict[str, Any]
-            Dictionary of all attribute names and their values
+            A dictionary mapping attribute names (as strings) to their corresponding values for all
+            attributes of the instance, including public, protected, private, and dunder attributes.
+
+        Notes
+        -----
+        - The returned dictionary includes all instance attributes, regardless of their visibility.
+        - Private attribute names are unmangled (class name prefix is removed).
+        - The result is cached in the instance to avoid redundant computation on repeated calls.
         """
-        return {
-            **self.getPublicAttributes(),
-            **self.getProtectedAttributes(),
-            **self.getPrivateAttributes(),
-            **self.getDunderAttributes()
-        }
+
+        # Check if the cache for attributes exists; if not, compute and store it
+        if not hasattr(self, "_ReflectionInstance__cacheGetAttributes"):
+
+            # Merge all attribute dictionaries from different visibility levels
+            self.__cacheGetAttributes = {
+                **self.getPublicAttributes(),
+                **self.getProtectedAttributes(),
+                **self.getPrivateAttributes(),
+                **self.getDunderAttributes()
+            }
+
+        # Return the cached dictionary of attributes
+        return self.__cacheGetAttributes
 
     def getPublicAttributes(self) -> Dict[str, Any]:
         """
@@ -634,24 +687,44 @@ class ReflectionInstance(IReflectionInstance):
 
     def getMethods(self) -> List[str]:
         """
-        Get all method names of the instance.
+        Retrieve all method names associated with the instance, including public, protected, private,
+        class, and static methods.
+
+        This method aggregates method names from various categories (public, protected, private, class,
+        and static) by calling the corresponding getter methods. The result is cached for subsequent calls
+        to improve performance.
 
         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(),
-        ]
+            A list containing the names of all methods (instance, class, and static) defined on the instance's class,
+            including public, protected, and private methods.
+
+        Notes
+        -----
+        - The returned list includes method names from all visibility levels (public, protected, private),
+          as well as class and static methods.
+        - The result is cached in the instance to avoid redundant computation on repeated calls.
+        """
+
+        # Check if the cache for method names exists; if not, compute and store it
+        if not hasattr(self, "_ReflectionInstance__cacheGetMethods"):
+
+            # Compute and cache the list of method names
+            self.__cacheGetMethods = [
+                *self.getPublicMethods(),
+                *self.getProtectedMethods(),
+                *self.getPrivateMethods(),
+                *self.getPublicClassMethods(),
+                *self.getProtectedClassMethods(),
+                *self.getPrivateClassMethods(),
+                *self.getPublicStaticMethods(),
+                *self.getProtectedStaticMethods(),
+                *self.getPrivateStaticMethods(),
+            ]
+
+        # Return the cached list of method names
+        return self.__cacheGetMethods
 
     def getPublicMethods(self) -> List[str]:
         """

{orionis-0.611.0 → orionis-0.612.0}/orionis/test/core/unit_test.py

@@ -665,11 +665,13 @@ class UnitTest(IUnitTest):
         - If a debug keyword is found, disables live console output for the test run.
         """
         try:
+
             # Gather method names to inspect: main test method and common setup/teardown hooks
-            method_name = getattr(test_case, "_testMethodName", None)
+            rf_instance = ReflectionInstance(test_case)
+            method_name = rf_instance.getAttribute("_testMethodName")
             extra_methods = ["setUp", "tearDown", "onSetup", "onTeardown"]
             method_names_to_check = [method_name] if method_name else []
-            method_names_to_check += [m for m in extra_methods if hasattr(test_case, m)]
+            method_names_to_check += [m for m in extra_methods if rf_instance.hasMethod(m)]
 
             # Inspect each method's source code for debug keywords
             for mname in method_names_to_check:
@@ -681,7 +683,7 @@ class UnitTest(IUnitTest):
                 try:
 
                     # Retrieve the source code of the method
-                    source = inspect.getsource(getattr(test_case, mname))
+                    source = rf_instance.getSourceCode(mname)
 
                 except Exception:
 
@@ -705,6 +707,7 @@ class UnitTest(IUnitTest):
                         if self.__live_console is True:
                             self.__live_console = False
                         return True
+
         except Exception:
 
             # On any error during inspection, return False

{orionis-0.611.0 → orionis-0.612.0/orionis.egg-info}/PKG-INFO

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