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

tests/support/inspection/fakes/fake_reflect_instance.py

@@ -1,146 +1,381 @@
 import asyncio
 
 class BaseFakeClass:
+    """
+    A base class for creating fake or mock classes in tests.
+
+    This class serves as a simple parent class for test doubles used in inspection-related tests.
+    """
     pass
 
 class FakeClass(BaseFakeClass):
     """
-    FakeClass is a test double for inspection and reflection scenarios.
-    Attributes:
-        class_attr (str): A class-level attribute with a default value "class_value".
-    Instance Attributes:
-        public_attr (int): A public instance attribute initialized to 42.
-        _protected_attr (str): A protected instance attribute initialized to "protected".
-        __private_attr (str): A private instance attribute initialized to "private".
-        dynamic_attr: An instance attribute initialized to None.
-        __dd__ (str): A dunder-named attribute initialized to "dunder_value".
+    FakeClass is a test double class designed to simulate a variety of attribute and method visibilities for inspection and testing purposes.
+    This class provides:
+    - Public, protected, and private class-level and instance-level attributes.
+    - Public, protected, and private properties.
+    - Synchronous and asynchronous instance methods with varying visibilities.
+    - Synchronous and asynchronous class methods with varying visibilities.
+    - Synchronous and asynchronous static methods with varying visibilities.
+        public_attr (int): A public class and instance attribute set to 42.
+        dynamic_attr: A public attribute initialized to None, can be set dynamically.
+        _protected_attr (str): A protected class and instance attribute set to "protected".
+        __private_attr (str): A private class and instance attribute set to "private".
+    Properties:
+        computed_public_property (str): Returns "public property".
+        _computed_property_protected (str): Returns "protected property".
+        __computed_property_private (str): Returns "private property".
     Methods:
-        instanceMethod(x: int, y: int) -> int:
-            Adds two numbers and returns the result.
-        computed_property -> str:
-            A computed property that returns a string based on public_attr.
-        classMethod() -> str:
-            Class method returning a string representation of the class attribute.
-        _classMethodProte() -> str:
-            Protected class method returning a string representation of the class attribute.
-        __classMethodPP() -> str:
-            Private class method returning a string representation of the class attribute.
+        instanceSyncMethod(x: int, y: int) -> int:
+        instanceAsyncMethod(x: int, y: int) -> int:
+        _protectedsyncMethod(x: int, y: int) -> int:
+            Protected synchronous addition method.
+        _protectedAsyncMethod(x: int, y: int) -> int:
+            Protected asynchronous addition method.
+        __privateSyncMethod(x: int, y: int) -> int:
+            Private synchronous addition method.
+        __privateAsyncMethod(x: int, y: int) -> int:
+            Private asynchronous addition method.
+    Class Methods:
+        classSyncMethod(x: int, y: int) -> int:
+        classAsyncMethod(x: int, y: int) -> int:
+        _classMethodProtected(x: int, y: int) -> int:
+            Protected synchronous class addition method.
+        _classAsyncMethodProtected(x: int, y: int) -> int:
+            Protected asynchronous class addition method.
+        __classMethodPrivate(x: int, y: int) -> int:
+            Private synchronous class addition method.
+        __classAsyncMethodPrivate(x: int, y: int) -> int:
+            Private asynchronous class addition method.
+    Static Methods:
         staticMethod(text: str) -> str:
-            Static method that returns the uppercase version of the input text.
-        __staticMethodPP(text: str) -> str:
-            Private static method that returns the uppercase version of the input text.
-        staticAsyncMethod(text: str) -> Awaitable[str]:
-            Asynchronous static method that returns the uppercase version of the input text after a delay.
-        __privateMethod() -> str:
-            Private instance method returning a string indicating it is private.
-        _protectedMethod() -> str:
-            Protected instance method returning a string indicating it is protected.
-        asyncMethod() -> Awaitable[str]:
-            Asynchronous instance method returning a string indicating it is async.
-        __str__() -> Awaitable[str]:
-            Asynchronous string representation of the instance.
+            Synchronously converts the input text to uppercase.
+        staticAsyncMethod(text: str) -> str:
+            Asynchronously converts the input text to uppercase.
+        _staticMethodProtected(text: str) -> str:
+            Protected synchronous static method to uppercase text.
+        _staticAsyncMethodProtected(text: str) -> str:
+            Protected asynchronous static method to uppercase text.
+        __staticMethodPrivate(text: str) -> str:
+            Private synchronous static method to uppercase text.
+        __staticAsyncMethodPrivate(text: str) -> str:
+            Private asynchronous static method to uppercase text.
+    Note:
+        This class is intended for testing and inspection of attribute and method visibility, including Python's name mangling for private members.
     """
 
-    class_attr: str = "class_value"
+    # Class-level attribute (Public)
+    public_attr: int = 42
+    dynamic_attr = None
 
-    def __init__(self) -> None:
-        self.public_attr = 42
-        self._protected_attr = "protected"
-        self.__private_attr = "private"
-        self.dynamic_attr = None
-        self.__dd__ = "dunder_value"
+    # Class-level attribute (Protected)
+    _protected_attr: str = "protected"
 
-    def instanceMethod(self, x: int, y: int) -> int:
-        """Adds two numbers."""
-        return x + y
+    # Class-level attribute (Private)
+    __private_attr: str = "private"
+    __dd__: str = "dunder_value"
 
     @property
-    def computed_property(self) -> str:
-        """A computed property."""
-        return f"public"
+    def computed_public_property(self) -> str:
+        """
+        Returns the string "public" as a computed property.
+
+        Returns:
+            str: The string "public".
+        """
+        return f"public property"
 
     @property
     def _computed_property_protected(self) -> str:
+        """
+        Returns a string indicating that this is a protected computed property.
+
+        Returns:
+            str: The string "protected".
+        """
         """A computed property."""
-        return f"protected"
+        return f"protected property"
 
     @property
     def __computed_property_private(self) -> str:
-        """A computed property."""
-        return f"private"
+        """
+        Returns the string "private".
+
+        This is a private computed property method, typically used for internal logic or testing purposes.
+
+        Returns:
+            str: The string "private".
+        """
+        return f"private property"
+
+    def __init__(self) -> None:
+        """
+        Initializes the instance with various attributes for testing attribute visibility.
+
+        Attributes:
+            public_attr (int): A public attribute set to 42.
+            _protected_attr (str): A protected attribute set to "protected".
+            __private_attr (str): A private attribute set to "private".
+            dynamic_attr: An attribute initialized to None, can be set dynamically.
+            __dd__ (str): A dunder (double underscore) attribute set to "dunder_value".
+        """
+
+        # Initialize attributes (Publics)
+        self.public_attr = 42
+        self.dynamic_attr = None
+
+        # Initialize attributes (Protected)
+        self._protected_attr = "protected"
+
+        # Initialize attributes (Private)
+        self.__private_attr = "private"
+        self.__dd__ = "dunder_value"
+
+    def instanceSyncMethod(self, x: int, y: int) -> int:
+        """
+        Synchronously adds two integers and returns the result.
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        return x + y
+
+    async def instanceAsyncMethod(self, x: int, y: int) -> int:
+        """
+        Asynchronously adds two integers and returns the result.
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        await asyncio.sleep(0.1)
+        return x + y
+
+    def _protectedsyncMethod(self, x: int, y: int) -> int:
+        """
+        Synchronously adds two integers and returns the result (protected method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        return x + y
+
+    async def _protectedAsyncMethod(self, x: int, y: int) -> int:
+        """
+        Asynchronously adds two integers and returns the result (protected method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        await asyncio.sleep(0.1)
+        return x + y
+
+    def __privateSyncMethod(self, x: int, y: int) -> int:
+        """
+        Synchronously adds two integers and returns the result (private method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        return x + y
+
+    async def __privateAsyncMethod(self, x: int, y: int) -> int:
+        """
+        Asynchronously adds two integers and returns the result (private method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        await asyncio.sleep(0.1)
+        return x + y
 
     @classmethod
-    def classMethod(cls) -> str:
-        """A class method."""
-        return f"Class attr: {cls.class_attr}"
+    def classSyncMethod(cls, x: int, y: int) -> int:
+        """
+        Synchronously adds two integers and returns the result (class method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        return x + y
 
     @classmethod
-    async def classMethodAsync(cls) -> str:
-        """A class method."""
-        return f"Class attr: {cls.class_attr}"
+    async def classAsyncMethod(cls, x: int, y: int) -> int:
+        """
+        Asynchronously adds two integers and returns the result (class method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        await asyncio.sleep(0.1)
+        return x + y
 
     @classmethod
-    def _classMethodProte(cls) -> str:
-        """A class method."""
-        return f"Class attr: {cls.class_attr}"
+    def _classMethodProtected(cls, x: int, y: int) -> int:
+        """
+        Synchronously adds two integers and returns the result (protected class method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        return x + y
 
     @classmethod
-    async def _classMethodProteAsync(cls) -> str:
-        """A class method."""
-        return f"Class attr: {cls.class_attr}"
+    async def _classAsyncMethodProtected(cls, x: int, y: int) -> int:
+        """
+        Asynchronously adds two integers and returns the result (protected class method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        await asyncio.sleep(0.1)
+        return x + y
 
     @classmethod
-    def __classMethodPP(cls) -> str:
-        """A class method."""
-        return f"Class attr: {cls.class_attr}"
+    def __classMethodPrivate(cls, x: int, y: int) -> int:
+        """
+        Synchronously adds two integers and returns the result (private class method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        return x + y
 
     @classmethod
-    async def __classMethodPPAsync(cls) -> str:
-        """A class method."""
-        return f"Class attr: {cls.class_attr}"
+    async def __classAsyncMethodPrivate(cls, x: int, y: int) -> int:
+        """
+        Asynchronously adds two integers and returns the result (private class method).
+
+        Args:
+            x (int): The first integer to add.
+            y (int): The second integer to add.
+
+        Returns:
+            int: The sum of x and y.
+        """
+        await asyncio.sleep(0.1)
+        return x + y
 
     @staticmethod
     def staticMethod(text: str) -> str:
-        """A static method."""
-        return text.upper()
+        """
+        Synchronously converts the input text to uppercase (static method).
 
-    @staticmethod
-    def __staticMethodSYNC(text: str) -> str:
-        """A static method. Ejemplo de método privado."""
+        Args:
+            text (str): The input string.
+
+        Returns:
+            str: The uppercase version of the input string.
+        """
         return text.upper()
 
     @staticmethod
     async def staticAsyncMethod(text: str) -> str:
-        """An asynchronous static method."""
+        """
+        Asynchronously converts the input text to uppercase (static method).
+
+        Args:
+            text (str): The input string.
+
+        Returns:
+            str: The uppercase version of the input string.
+        """
         await asyncio.sleep(0.1)
         return text.upper()
 
     @staticmethod
-    def _staticMethodPro(text: str) -> str:
-        """A static method."""
+    def _staticMethodProtected(text: str) -> str:
+        """
+        Synchronously converts the input text to uppercase (protected static method).
+
+        Args:
+            text (str): The input string.
+
+        Returns:
+            str: The uppercase version of the input string.
+        """
         return text.upper()
 
     @staticmethod
-    async def _staticMethodProAsync(text: str) -> str:
-        """A static method."""
+    async def _staticAsyncMethodProtected(text: str) -> str:
+        """
+        Asynchronously converts the input text to uppercase (protected static method).
+
+        Args:
+            text (str): The input string.
+
+        Returns:
+            str: The uppercase version of the input string.
+        """
+        await asyncio.sleep(0.1)
         return text.upper()
 
     @staticmethod
-    async def __staticMethodPrivateAsync(text: str) -> str:
-        """A static method."""
-        return text.upper()
+    def __staticMethodPrivate(text: str) -> str:
+        """
+        Synchronously converts the input text to uppercase (private static method).
 
-    def __privateMethod(self) -> str:
-        """A 'private' method."""
-        return "This is private"
+        Args:
+            text (str): The input string.
 
-    def _protectedMethod(self) -> str:
-        """A 'protected' method."""
-        return "This is protected"
+        Returns:
+            str: The uppercase version of the input string.
+        """
+        return text.upper()
 
-    async def asyncMethod(self) -> str:
-        """An async method."""
-        return "This is async"
+    @staticmethod
+    async def __staticAsyncMethodPrivate(text: str) -> str:
+        """
+        Asynchronously converts the input text to uppercase (private static method).
 
-    async def __str__(self):
-        return super().__str__()
+        Args:
+            text (str): The input string.
+
+        Returns:
+            str: The uppercase version of the input string.
+        """
+        await asyncio.sleep(0.1)
+        return text.upper()