orionis 0.202.0__py3-none-any.whl → 0.204.0__py3-none-any.whl

orionis/framework.py

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

orionis/luminate/support/inspection/reflexion_instance.py

@@ -99,6 +99,32 @@ class ReflexionInstance:
             predicate=inspect.ismethod
         )]
 
+    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']
+        """
+        return [
+            name for name in dir(self._instance.__class__)
+            if not name.startswith('_') and
+            isinstance(inspect.getattr_static(self._instance.__class__, name), staticmethod)
+        ]
+
     def getPropertyNames(self) -> List[str]:
         """Get all property names of the instance.
 

orionis/luminate/test/test_output.py

@@ -0,0 +1,65 @@
+import sys
+from orionis.luminate.console.output.console import Console
+import os
+
+class PrinterInTest:
+    """
+    A utility class for printing debug information during testing. This class temporarily
+    redirects the standard output and error streams to their original states to ensure
+    proper console output, and provides contextual information about the file and line
+    number where the print call was made.
+    Methods
+    -------
+    print(*args)
+        Prints the provided arguments to the console with contextual information
+        about the file and line number of the caller. If no arguments are provided,
+        the method does nothing.
+    """
+
+    def print(*args):
+        """
+        Prints the provided arguments to the console with contextual information
+        about the file and line number of the caller. The output is formatted with
+        muted text decorations for better readability.
+        Parameters
+        ----------
+        *args : tuple
+            The arguments to be printed. The first argument is ignored, and the
+            remaining arguments are printed. If no arguments are provided, the
+            method does nothing.
+        Notes
+        -----
+        - The method temporarily redirects `sys.stdout` and `sys.stderr` to their
+          original states (`sys.__stdout__` and `sys.__stderr__`) to ensure proper
+          console output.
+        - The contextual information includes the file path and line number of the
+          caller, which is displayed in a muted text format.
+        - After printing, the method restores the original `sys.stdout` and
+          `sys.stderr` streams.
+        """
+
+        # Check if the first argument is a string and remove it from the args tuple
+        if len(args) == 0:
+            return
+
+        # Change the output stream to the original stdout and stderr
+        # to avoid any issues with the console output
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+
+        # Get the file name and line number of the caller
+        # using sys._getframe(1) to access the caller's frame
+        _file = os.path.relpath(sys._getframe(1).f_code.co_filename, start=os.getcwd())
+        _method = sys._getframe(1).f_code.co_name
+        _line = sys._getframe(1).f_lineno
+
+        # Print the contextual information and the provided arguments
+        Console.textMuted(f"[DEBUG] File: {_file}, Line: {_line}, Method: {_method}")
+        print(*args[1:], end='\n')
+        Console.newLine()
+
+        # Restore the original stdout and stderr streams
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr

{orionis-0.202.0.dist-info → orionis-0.204.0.dist-info}/METADATA

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

{orionis-0.202.0.dist-info → orionis-0.204.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=18MaKCn57mg1rxIum1RP9LmF_HV9qnuuhyrYS6ENti0,1469
+orionis/framework.py,sha256=fJPN2FnUX2ZiLCd2YqzdQCQJjBCPgXa-f7e91XLCcoA,1469
 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
@@ -174,12 +174,13 @@ orionis/luminate/support/inspection/reflection.py,sha256=x_UHBY9pBSKgct13-u1Wbho
 orionis/luminate/support/inspection/reflexion_abstract.py,sha256=T3Zsi2KT2cS2-Upu0NDcW5FTrcytTLxlmBfZ_KAYA3Y,554
 orionis/luminate/support/inspection/reflexion_concrete.py,sha256=0WOlLeTWLwMeAUReoaJetqlnT1_TxW_jMnbk_yXRR0g,549
 orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py,sha256=ZuAFoSPkgbOFMIbVR0hvlkKsm1dIpY1_bsXxZxvXcmU,801
-orionis/luminate/support/inspection/reflexion_instance.py,sha256=ROmZ-hxYdnrCsYdzjZyH4KhDZxKEWkDM5ZTPg4BmGmc,9079
+orionis/luminate/support/inspection/reflexion_instance.py,sha256=k6bpRYjLeTUDqquluYrDZUtBLpLuGe4wm7PMUM8Sz-E,9914
 orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=dag6QdVp1CydREWdpQvzAyOPX3q-lSb0_XzB0u3odQE,9629
 orionis/luminate/support/inspection/reflexion_module.py,sha256=OgBXpqNJHkmq-gX4rqFStv-WVNe9R38RsgUgfHpak8k,405
 orionis/luminate/support/inspection/reflexion_module_with_classname.py,sha256=YZHZI0XUZkSWnq9wrGxrIXtI64nY9yVSZoMe7PZXq8Y,620
 orionis/luminate/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/test/test_exception.py,sha256=21PILTXnMuL5-wT3HGKjIklt8VeIYDcQDN346i-BbJw,1336
+orionis/luminate/test/test_output.py,sha256=7QvkxbKOp56GcznjaJSX9I072gkut1NvuaexqO3v8BM,2768
 orionis/luminate/test/test_result.py,sha256=Px2_M70r_y7BntRITk_h0IPTbSTW5XhDyklMKHm3JJI,999
 orionis/luminate/test/test_status.py,sha256=vNKRmp1lud_ZGTayf3A8wO_0vEYdFABy_oMw-RcEc1c,673
 orionis/luminate/test/tests.py,sha256=KZRFHB6C8S2DN6JHqJ2sIuSNAUMh9JW1Yn-XGjXjjTw,2218
@@ -195,9 +196,16 @@ orionis/static/logos/OrionisFramework2.png,sha256=Z_-yBHNSo33QeSTyi-8GfiFozdRqUo
 orionis/static/logos/OrionisFramework3.png,sha256=BPG9ZB58vDALavI9OMmr8Ym0DQa44s5NL_3M4M6dIYs,193734
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis-0.202.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.202.0.dist-info/METADATA,sha256=kiVvQVX5rkTnqeLGvor85Qu4hFAhiCJopnuaX0u1j4E,3003
-orionis-0.202.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.202.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.202.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.202.0.dist-info/RECORD,,
+tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/example/test_example.py,sha256=IyhepxT7QPQcV2IYGuUDBWgd6sqDSko4-kImbRgqLX4,558
+tests/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/test_reflection.py,sha256=GhGtSJIsWQAthsHPattpmjTboQtwUlTCKct9PX5S8gI,7244
+tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/fakes/fake_reflection.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
+orionis-0.204.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.204.0.dist-info/METADATA,sha256=M3YrdUwxrIdbbcnYK7nGdBj-xh3DNh7fUJQzY-BD0U0,3003
+orionis-0.204.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.204.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.204.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.204.0.dist-info/RECORD,,

tests/example/test_example.py

@@ -0,0 +1,20 @@
+import unittest
+
+class TestExample(unittest.TestCase):
+    """
+    Unit tests for basic example functionality.
+    """
+
+    def testUnitExample(self):
+        """
+        Test that basic equality assertions work as expected.
+
+        Asserts
+        -------
+        1 == 1 : bool
+            Ensures that the integer 1 is equal to itself.
+        2 == 2 : bool
+            Ensures that the integer 2 is equal to itself.
+        """
+        self.assertEqual(1, 1)  # Check if 1 equals 1
+        self.assertEqual(2, 2)  # Check if 2 equals 2

tests/support/inspection/fakes/fake_reflection.py

@@ -0,0 +1,60 @@
+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
+    """
+
+    class_attr: str = "class_value"
+
+    def __init__(self) -> None:
+        self.public_attr = 42
+        self._private_attr = "secret"
+        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
+        """
+        return x + y
+
+    @property
+    def computed_property(self) -> str:
+        """A computed property."""
+        return f"Value: {self.public_attr}"
+
+    @classmethod
+    def class_method(cls) -> str:
+        """A class method."""
+        return f"Class attr: {cls.class_attr}"
+
+    @staticmethod
+    def static_method(text: str) -> str:
+        """A static method."""
+        return text.upper()
+
+    def __private_method(self) -> str:
+        """A 'private' method."""
+        return "This is private"
+
+    def _protected_method(self) -> str:
+        """A 'protected' method."""
+        return "This is protected"

tests/support/inspection/test_reflection.py

@@ -0,0 +1,147 @@
+import unittest
+from orionis.luminate.support.inspection.reflection import Reflection
+from orionis.luminate.support.inspection.reflexion_instance import ReflexionInstance
+from orionis.luminate.test.test_output import PrinterInTest
+from tests.support.inspection.fakes.fake_reflection import BaseFakeClass, FakeClass
+
+class TestReflection(unittest.TestCase, PrinterInTest):
+    """
+    Unit tests for the Reflection class.
+    This class tests the functionality of the Reflection class, ensuring that it correctly handles
+    """
+
+    def testReflectionInstanceExceptionValueError(self):
+        """Test that Reflection.instance raises ValueError for invalid types."""
+        with self.assertRaises(ValueError):
+            Reflection.instance(str)
+
+    def testReflectionInstance(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        self.assertIsInstance(Reflection.instance(FakeClass()), ReflexionInstance)
+
+    def testReflectionInstanceGetClassName(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertEqual(reflex.getClassName(), "FakeClass")
+
+    def testReflectionInstanceGetClass(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertEqual(reflex.getClass(), FakeClass)
+
+    def testReflectionInstanceGetModuleName(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertEqual(reflex.getModuleName(), "tests.support.inspection.fakes.fake_reflection")
+
+    def testReflectionInstanceGetAttributes(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        attributes = reflex.getAttributes()
+        self.assertTrue("public_attr" in attributes)
+        self.assertTrue("_private_attr" in attributes)
+        self.assertTrue("dynamic_attr" in attributes)
+
+    def testReflectionInstanceGetMethods(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getMethods()
+        self.assertTrue("instance_method" in methods)
+        self.assertTrue("class_method" in methods)
+
+    def testReflectionInstanceGetStaticMethods(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getStaticMethods()
+        self.assertTrue("static_method" in methods)
+
+    def testReflectionInstanceGetPropertyNames(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        properties = reflex.getPropertyNames()
+        self.assertTrue("computed_property" in properties)
+
+    def testReflectionInstanceCallMethod(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        result = reflex.callMethod("instance_method", 1, 2)
+        self.assertEqual(result, 3)
+
+    def testReflectionInstanceGetMethodSignature(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        signature = reflex.getMethodSignature("instance_method")
+        self.assertEqual(str(signature), "(x: int, y: int) -> int")
+
+    def testReflectionInstanceGetDocstring(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        docstring = reflex.getDocstring()
+        self.assertIn("This is a test class for ReflexionInstance", docstring)
+
+    def testReflectionInstanceGetBaseClasses(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        base_classes = reflex.getBaseClasses()
+        self.assertIn(BaseFakeClass, base_classes)
+
+    def testReflectionInstanceIsInstanceOf(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertTrue(reflex.isInstanceOf(BaseFakeClass))
+
+    def testReflectionInstanceGetSourceCode(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        source_code = reflex.getSourceCode()
+        self.assertIn("class FakeClass(BaseFakeClass):", source_code)
+
+    def testReflectionInstanceGetFileLocation(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        file_location = reflex.getFileLocation()
+        self.assertIn("fake_reflection.py", file_location)
+
+    def testReflectionInstanceGetAnnotations(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        annotations = reflex.getAnnotations()
+        self.assertEqual("{'class_attr': <class 'str'>}", str(annotations))
+
+    def testReflectionInstanceHasAttribute(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertTrue(reflex.hasAttribute("public_attr"))
+        self.assertFalse(reflex.hasAttribute("non_existent_attr"))
+
+    def testReflectionInstanceGetAttribute(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        attr_value = reflex.getAttribute("public_attr")
+        self.assertEqual(attr_value, 42)
+
+    def testReflectionInstanceGetCallableMembers(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        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)
+
+    def testReflectionInstanceSetAttribute(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+
+        # Create a new macro function
+        def myMacro(cls, num):
+            return cls.public_attr + num
+
+        # Create an instance of FakeClass and set the macro as an attribute
+        reflex = Reflection.instance(FakeClass())
+        reflex.setAttribute("myMacro", myMacro)
+
+        # Check if the macro was set correctly
+        self.assertTrue(reflex.hasAttribute("myMacro"))
+
+        # Call the macro method and check the result
+        result = reflex.callMethod("myMacro", reflex._instance, 3)
+        self.assertEqual(result, 45)