orionis 0.304.0__py3-none-any.whl → 0.306.0__py3-none-any.whl

orionis/support/introspection/reflexion_module.py

@@ -1,19 +0,0 @@
-class ReflexionModule:
-    """A reflection object encapsulating a module.
-
-    Parameters
-    ----------
-    module : str
-        The module name being reflected upon
-
-    Attributes
-    ----------
-    _module : str
-        The encapsulated module name
-    """
-
-    def __init__(self, module: str) -> None:
-        """Initialize with the module name."""
-        self._module = module
-
-

orionis/support/introspection/reflexion_module_with_classname.py

@@ -1,22 +0,0 @@
-class ReflexionModuleWithClassName:
-    """A reflection object encapsulating a module and a class name.
-
-    Parameters
-    ----------
-    module : str
-        The module name being reflected upon
-    class_name : str
-        The class name in the module
-
-    Attributes
-    ----------
-    _module : str
-        The encapsulated module name
-    _class_name : str
-        The encapsulated class name
-    """
-
-    def __init__(self, module: str, class_name: str) -> None:
-        """Initialize with the module name and class name."""
-        self._module = module
-        self._class_name = class_name

orionis/support/reflection.py

@@ -1,216 +0,0 @@
-import abc
-from typing import Any, Type, TypeVar
-from orionis._contracts.support.reflection import IReflection
-from orionis.support.introspection.helpers.functions import HelpersReflection
-from orionis.support.introspection.abstracts.reflect_abstract import ReflexionAbstract
-from orionis.support.introspection.reflexion_concrete import ReflexionConcrete
-from orionis.support.introspection.reflexion_concrete_with_abstract import ReflexionConcreteWithAbstract
-from orionis.support.introspection.instances.reflection_instance import ReflectionInstance
-from orionis.support.introspection.reflexion_instance_with_abstract import ReflexionInstanceWithAbstract
-from orionis.support.introspection.reflexion_module import ReflexionModule
-from orionis.support.introspection.reflexion_module_with_classname import ReflexionModuleWithClassName
-
-T = TypeVar('T')
-ABC = TypeVar('ABC', bound=abc.ABC)
-
-class Reflection(IReflection):
-    """A static class providing factory methods for creating reflection objects.
-
-    This class provides methods to create various types of reflection objects
-    that encapsulate different aspects of Python's reflection capabilities.
-    Each method validates its inputs before creating the appropriate reflection object.
-
-    Methods
-    -------
-    instance(instance: Any) -> ReflexionInstance
-        Creates a reflection object for a class instance
-    instanceWithAbstract(instance: Any, abstract: Type[ABC]) -> ReflexionInstanceWithAbstract
-        Creates a reflection object for a class instance with its abstract parent
-    abstract(abstract: Type[ABC]) -> ReflexionAbstract
-        Creates a reflection object for an abstract class
-    concrete(concrete: Type[T]) -> ReflexionConcrete
-        Creates a reflection object for a concrete class
-    concreteWithAbstract(concrete: Type[T], abstract: Type[ABC]) -> ReflexionConcreteWithAbstract
-        Creates a reflection object for a concrete class with its abstract parent
-    module(module: str) -> ReflexionModule
-        Creates a reflection object for a module
-    moduleWithClassName(module: str, class_name: str) -> ReflexionModuleWithClassName
-        Creates a reflection object for a module with a specific class name
-    """
-
-    @staticmethod
-    def instance(instance: Any) -> 'ReflectionInstance':
-        """Create a reflection object for a class instance.
-
-        Parameters
-        ----------
-        instance : Any
-            The instance to reflect upon
-
-        Returns
-        -------
-        ReflectionInstance
-            A reflection object encapsulating the instance
-
-        Raises
-        ------
-        TypeError
-            If the input is not an object instance
-        ValueError
-            If the instance is from builtins, abc, or __main__
-        """
-        HelpersReflection.ensureUserDefinedClassInstance(instance)
-        return ReflectionInstance(instance)
-
-    @staticmethod
-    def instanceWithAbstract(instance: Any, abstract: Type[ABC]) -> 'ReflexionInstanceWithAbstract':
-        """Create a reflection object for a class instance with its abstract parent.
-
-        Parameters
-        ----------
-        instance : Any
-            The instance to reflect upon
-        abstract : Type[ABC]
-            The abstract parent class
-
-        Returns
-        -------
-        ReflexionInstanceWithAbstract
-            A reflection object encapsulating the instance and its abstract parent
-
-        Raises
-        ------
-        TypeError
-            If the instance is not an object or abstract is not a class
-        ValueError
-            If the instance is invalid or abstract is not actually abstract
-        """
-        HelpersReflection.ensureUserDefinedClassInstance(instance)
-        HelpersReflection.ensureAbstractClass(abstract)
-        return ReflexionInstanceWithAbstract(instance, abstract)
-
-    @staticmethod
-    def abstract(abstract: Type[ABC]) -> 'ReflexionAbstract':
-        """Create a reflection object for an abstract class.
-
-        Parameters
-        ----------
-        abstract : Type[ABC]
-            The abstract class to reflect upon
-
-        Returns
-        -------
-        ReflexionAbstract
-            A reflection object encapsulating the abstract class
-
-        Raises
-        ------
-        TypeError
-            If the input is not a class
-        ValueError
-            If the class is not abstract
-        """
-        HelpersReflection.ensureAbstractClass(abstract)
-        return ReflexionAbstract(abstract)
-
-    @staticmethod
-    def concrete(concrete: Type[T]) -> 'ReflexionConcrete':
-        """Create a reflection object for a concrete class.
-
-        Parameters
-        ----------
-        concrete : Type[T]
-            The concrete class to reflect upon
-
-        Returns
-        -------
-        ReflexionConcrete
-            A reflection object encapsulating the concrete class
-
-        Raises
-        ------
-        TypeError
-            If the input is not a class
-        ValueError
-            If the class is abstract or cannot be instantiated
-        """
-        HelpersReflection.ensureInstantiableClass(concrete)
-        return ReflexionConcrete(concrete)
-
-    @staticmethod
-    def concreteWithAbstract(concrete: Type[T], abstract: Type[ABC]) -> 'ReflexionConcreteWithAbstract':
-        """Create a reflection object for a concrete class with its abstract parent.
-
-        Parameters
-        ----------
-        concrete : Type[T]
-            The concrete class to reflect upon
-        abstract : Type[ABC]
-            The abstract parent class
-
-        Returns
-        -------
-        ReflexionConcreteWithAbstract
-            A reflection object encapsulating the concrete class and its abstract parent
-
-        Raises
-        ------
-        TypeError
-            If either input is not a class
-        ValueError
-            If concrete is not instantiable or abstract is not actually abstract
-        """
-        HelpersReflection.ensureInstantiableClass(concrete)
-        HelpersReflection.ensureAbstractClass(abstract)
-        return ReflexionConcreteWithAbstract(concrete, abstract)
-
-    @staticmethod
-    def module(module: str) -> 'ReflexionModule':
-        """Create a reflection object for a module.
-
-        Parameters
-        ----------
-        module : str
-            The module name to reflect upon
-
-        Returns
-        -------
-        ReflexionModule
-            A reflection object encapsulating the module
-
-        Raises
-        ------
-        TypeError
-            If the input is not a string
-        ValueError
-            If the module cannot be imported
-        """
-        HelpersReflection.ensureValidModule(module)
-        return ReflexionModule(module)
-
-    @staticmethod
-    def moduleWithClassName(module: str, class_name: str) -> 'ReflexionModuleWithClassName':
-        """Create a reflection object for a module with a specific class name.
-
-        Parameters
-        ----------
-        module : str
-            The module name to reflect upon
-        class_name : str
-            The class name to look for in the module
-
-        Returns
-        -------
-        ReflexionModuleWithClassName
-            A reflection object encapsulating the module and class name
-
-        Raises
-        ------
-        TypeError
-            If either input is not a string
-        ValueError
-            If the module cannot be imported or the class doesn't exist in it
-        """
-        HelpersReflection.ensureValidModule(module)
-        HelpersReflection.ensureValidClassName(class_name)
-        return ReflexionModuleWithClassName(module, class_name)

orionis/test/facade/contracts/test_suite.py

@@ -1,25 +0,0 @@
-from abc import ABC, abstractmethod
-from orionis.test.suite.test_unit import UnitTest
-
-class ITestSuite(ABC):
-
-    @abstractmethod
-    def run(self) -> UnitTest:
-        """
-        Runs the test suite based on the provided configuration.
-
-        Initializes a UnitTest suite, configures it with parameters from the Configuration object,
-        discovers test folders matching the specified pattern, adds the discovered tests to the suite,
-        executes the test suite, and returns the results.
-
-        Returns
-        -------
-        UnitTest
-            The result of the executed test suite.
-
-        Raises
-        ------
-        OrionisTestConfigException
-            If the provided configuration is not an instance of Configuration.
-        """
-        pass

tests/support/inspection/fakes/fake_reflect_abstract.py

@@ -1,276 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Callable
-from functools import wraps
-
-def decorator_example(func: Callable) -> Callable:
-    """Example decorator for testing purposes.
-
-    Parameters
-    ----------
-    func : Callable
-        The function to be decorated
-
-    Returns
-    -------
-    Callable
-        The wrapped function
-
-    Notes
-    -----
-    This is a simple identity decorator used for testing decorator detection.
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-    return wrapper
-
-
-def another_decorator(func: Callable) -> Callable:
-    """Another example decorator for testing multiple decorators.
-
-    Parameters
-    ----------
-    func : Callable
-        The function to be decorated
-
-    Returns
-    -------
-    Callable
-        The wrapped function with added prefix
-
-    Examples
-    --------
-    >>> @another_decorator
-    ... def test(): return "hello"
-    >>> test()
-    'Decorated: hello'
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return f"Decorated: {func(*args, **kwargs)}"
-    return wrapper
-
-class FakeAbstractClass(ABC):
-    """A fake abstract class for testing reflection capabilities.
-
-    This class contains all elements needed to test ReflexionAbstract functionality:
-    - Abstract methods
-    - Concrete methods
-    - Static methods
-    - Class methods
-    - Properties
-    - Decorated methods
-    - Type annotations
-    - Protected/private methods
-
-    Attributes
-    ----------
-    class_attr : str
-        A class-level attribute with type annotation
-    _value : float
-        Protected attribute used by computed_property setter
-    """
-
-    public_class_attribute: str = "class_value"
-    _protected_class_attribute: str = "protected_class_attr"
-    __private_class_attribute: str = "private_class_attr"
-
-    @abstractmethod
-    def abstract_method(self, x: int, y: int) -> int:
-        """Required abstract method.
-
-        Parameters
-        ----------
-        x : int
-            First integer parameter
-        y : int
-            Second integer parameter
-
-        Returns
-        -------
-        int
-            The result of some operation
-
-        Notes
-        -----
-        This method must be implemented by concrete subclasses.
-        """
-        pass
-
-    @abstractmethod
-    def another_abstract(self, text: str) -> str:
-        """Another required abstract method.
-
-        Parameters
-        ----------
-        text : str
-            Input string to process
-
-        Returns
-        -------
-        str
-            Processed string result
-        """
-        pass
-
-    def concrete_method(self, value: float) -> str:
-        """Concrete implemented method.
-
-        Parameters
-        ----------
-        value : float
-            Numeric value to format
-
-        Returns
-        -------
-        str
-            Formatted string representation
-        """
-        return f"Value: {value}"
-
-    @staticmethod
-    def static_helper(flag: bool) -> str:
-        """Static helper method.
-
-        Parameters
-        ----------
-        flag : bool
-            Boolean flag to determine output
-
-        Returns
-        -------
-        str
-            "Enabled" if flag is True, "Disabled" otherwise
-        """
-        return "Enabled" if flag else "Disabled"
-
-    @classmethod
-    def create_instance(cls) -> 'FakeAbstractClass':
-        """Class method factory.
-
-        Returns
-        -------
-        FakeAbstractClass
-            New instance of the class
-
-        Notes
-        -----
-        This cannot actually instantiate the abstract class, but serves
-        as an example of a class method.
-        """
-        return cls()
-
-    @property
-    def computed_property(self) -> float:
-        """Computed property example.
-
-        Returns
-        -------
-        float
-            The value of pi approximation
-        """
-        return 3.1416
-
-    @computed_property.setter
-    def computed_property(self, value: float):
-        """Setter for computed property.
-
-        Parameters
-        ----------
-        value : float
-            New value to set
-        """
-        self._value = value
-
-    @decorator_example
-    @another_decorator
-    def decorated_method(self) -> str:
-        """Method with multiple decorators.
-
-        Returns
-        -------
-        str
-            Always returns "decorated" with decorator transformations
-
-        Notes
-        -----
-        Used to test decorator inspection functionality.
-        """
-        return "decorated"
-
-    def _protected_method(self) -> str:
-        """Protected method (should be filtered in results).
-
-        Returns
-        -------
-        str
-            Constant string "protected"
-        """
-        return "protected"
-
-    def __private_method(self) -> str:
-        """Private method (should be filtered in results).
-
-        Returns
-        -------
-        str
-            Constant string "private"
-        """
-        return "private"
-
-    async def asynchronous(self) -> str:
-        """Asynchronous method example.
-
-        Returns
-        -------
-        str
-            Constant string "asynchronous"
-        """
-        return "asynchronous"
-
-    @staticmethod
-    async def asynchronous_static() -> str:
-        """Asynchronous static method example.
-
-        Returns
-        -------
-        str
-            Constant string "asynchronous static"
-        """
-        return "asynchronous static"
-
-    @property
-    @abstractmethod
-    def abstract_properties(self) -> str:
-        """Abstract property example.
-
-        Returns
-        -------
-        str
-            Abstract property value
-        """
-        pass
-
-    @classmethod
-    @abstractmethod
-    def abstract_class_method(cls) -> str:
-        """Abstract class method example.
-
-        Returns
-        -------
-        str
-            Abstract class method value
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def abstract_static_method() -> str:
-        """Abstract static method example.
-
-        Returns
-        -------
-        str
-            Abstract static method value
-        """
-        pass

tests/support/inspection/fakes/fake_reflection_concrete.py

@@ -1,44 +0,0 @@
-class BaseExample:
-    """Base class to test inheritance."""
-
-    def baseMethod(self) -> str:
-        return "Base method called"
-
-class FakeExample(BaseExample):
-    """This is a fake example class for testing reflection."""
-
-    class_attr: int = 42
-    another_attr = "hello"
-
-    def __init__(self, value: int = 10) -> None:
-        self.instance_attr = value
-
-    @property
-    def prop(self) -> int:
-        """A read-only property returning a fixed number."""
-        return 10
-
-    @property
-    def prop_with_getter(self) -> str:
-        return "read-only"
-
-    def method_one(self, x: int) -> int:
-        return x * 2
-
-    def method_two(self, a: str, b: str = "default") -> str:
-        return a + b
-
-    @staticmethod
-    def static_method() -> str:
-        return "I am static"
-
-    @staticmethod
-    def _private_static():
-        pass
-
-    @classmethod
-    def class_method(cls) -> str:
-        return f"I am class method of {cls.__name__}"
-
-    def _private_method(self):
-        pass

tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py

@@ -1,78 +0,0 @@
-import abc
-from typing import Any, Dict, List
-
-class AbstractService(abc.ABC):
-    """
-    Abstract interface for service-like behavior.
-
-    Methods
-    -------
-    process(data: str) -> bool
-        Perform processing on input data.
-
-    reset() -> None
-        Reset the internal state of the service.
-
-    configure(options: Dict[str, Any]) -> None
-        Apply configuration settings to the service.
-
-    get_logs(limit: int = 10) -> List[str]
-        Retrieve a limited number of log messages.
-
-    Properties
-    ----------
-    status : str
-        Current status of the service.
-    """
-
-    @abc.abstractmethod
-    def process(self, data: str) -> bool:
-        """Perform processing on input data."""
-        pass
-
-    @abc.abstractmethod
-    def reset(self) -> None:
-        """Reset the internal state of the service."""
-        pass
-
-    @abc.abstractmethod
-    def configure(self, options: Dict[str, Any]) -> None:
-        """Apply configuration settings to the service."""
-        pass
-
-    @abc.abstractmethod
-    def get_logs(self, limit: int = 10) -> List[str]:
-        """Retrieve a limited number of log messages."""
-        pass
-
-    @property
-    @abc.abstractmethod
-    def status(self) -> str:
-        """Current status of the service."""
-        pass
-
-class PartiallyImplementedService:
-    """
-    A partial implementation of AbstractService.
-
-    This class mimics the interface but lacks some methods/properties,
-    making it useful for testing reflection-based validation.
-    """
-
-    def process(self, data: str) -> bool:
-        """Basic processing implementation."""
-        return bool(data)
-
-    def get_logs(self, limit: int = 10) -> List[str]:
-        """Return a fixed list of logs (mock implementation)."""
-        return [f"log {i}" for i in range(limit)]
-
-    # ❌ Missing: reset()
-    # ❌ Missing: configure()
-    # ❌ Missing: status (property)
-
-    def extra(self) -> str:
-        """An extra method not part of the abstract interface."""
-        return "Just extra"
-
-    version: str = "1.0"