orionis 0.663.0__tar.gz → 0.664.0__tar.gz

{orionis-0.663.0/orionis.egg-info → orionis-0.664.0}/PKG-INFO

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

{orionis-0.663.0 → orionis-0.664.0}/orionis/metadata/framework.py

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

{orionis-0.663.0 → orionis-0.664.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.663.0 → orionis-0.664.0}/orionis.egg-info/SOURCES.txt

@@ -94,16 +94,6 @@ orionis/container/facades/__init__.py
 orionis/container/facades/facade.py
 orionis/container/providers/__init__.py
 orionis/container/providers/service_provider.py
-orionis/container/validators/__init__.py
-orionis/container/validators/implements.py
-orionis/container/validators/is_abstract_class.py
-orionis/container/validators/is_callable.py
-orionis/container/validators/is_concrete_class.py
-orionis/container/validators/is_instance.py
-orionis/container/validators/is_not_subclass.py
-orionis/container/validators/is_subclass.py
-orionis/container/validators/is_valid_alias.py
-orionis/container/validators/lifetime.py
 orionis/failure/__init__.py
 orionis/failure/catch.py
 orionis/failure/base/__init__.py

orionis-0.663.0/orionis/container/validators/__init__.py

@@ -1,21 +0,0 @@
-from .implements import ImplementsAbstractMethods
-from .is_abstract_class import IsAbstractClass
-from .is_concrete_class import IsConcreteClass
-from .is_instance import IsInstance
-from .is_callable import IsCallable
-from .is_subclass import IsSubclass
-from .is_not_subclass import IsNotSubclass
-from .is_valid_alias import IsValidAlias
-from .lifetime import LifetimeValidator
-
-__all__ = [
-    "ImplementsAbstractMethods",
-    "IsAbstractClass",
-    "IsConcreteClass",
-    "IsInstance",
-    "IsCallable",
-    "IsSubclass",
-    "IsNotSubclass",
-    "IsValidAlias",
-    "LifetimeValidator",
-]

orionis-0.663.0/orionis/container/validators/implements.py

@@ -1,73 +0,0 @@
-from typing import Callable, Any
-from orionis.services.introspection.objects.types import Type
-from orionis.container.exceptions import OrionisContainerException
-
-class __ImplementsAbstractMethods:
-    """
-    Validator that ensures a concrete class or instance implements all abstract methods of an abstract class.
-    """
-
-    def __call__(
-        self,
-        *,
-        abstract: Callable[..., Any] = None,
-        concrete: Callable[..., Any] = None,
-        instance: Any = None
-    ) -> None:
-        """
-        Validates that a concrete class or instance implements all abstract methods defined in an abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base class.
-        concrete : Callable[..., Any], optional
-            The class expected to implement the abstract methods.
-        instance : Any, optional
-            The instance expected to implement the abstract methods.
-
-        Raises
-        ------
-        OrionisContainerException
-            If any abstract method is not implemented.
-        """
-
-        # Validate that the abstract class is provided
-        if abstract is None:
-            raise OrionisContainerException("Abstract class must be provided for implementation check.")
-
-        # Check if the abstract class has abstract methods
-        abstract_methods = getattr(abstract, '__abstractmethods__', set())
-        if not abstract_methods:
-            raise OrionisContainerException(
-                f"The abstract class '{abstract.__name__}' does not define any abstract methods. "
-                "An abstract class must have at least one abstract method."
-            )
-
-        # Determine the target class or instance to check
-        target = concrete if concrete is not None else instance
-        if target is None:
-            raise OrionisContainerException("Either concrete class or instance must be provided for implementation check.")
-
-        # Validate that the target is a class or instance
-        target_class = target if Type(target).isClass() else target.__class__
-        target_name = target_class.__name__
-        abstract_name = abstract.__name__
-
-        # Check if the target class implements all abstract methods
-        not_implemented = []
-        for method in abstract_methods:
-            expected_method = str(method).replace(f"_{abstract_name}", f"_{target_name}")
-            if expected_method not in target_class.__dict__:
-                not_implemented.append(method)
-
-        # If any abstract methods are not implemented, raise an exception
-        if not_implemented:
-            formatted = "\n  • " + "\n  • ".join(not_implemented)
-            raise OrionisContainerException(
-                f"'{target_name}' does not implement the following abstract methods defined in '{abstract_name}':{formatted}\n"
-                "Please ensure that all abstract methods are implemented."
-            )
-
-# Exported singleton instance
-ImplementsAbstractMethods = __ImplementsAbstractMethods()

orionis-0.663.0/orionis/container/validators/is_abstract_class.py

@@ -1,34 +0,0 @@
-from typing import Callable, Any
-from orionis.services.introspection.abstract.reflection import ReflectionAbstract
-from orionis.container.exceptions import OrionisContainerTypeError
-
-class __IsAbstractClass:
-    """
-    Validator that ensures a class is an abstract class.
-    """
-
-    def __call__(self, abstract: Callable[..., Any], lifetime: str) -> None:
-        """
-        Ensures that the provided class is an abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The class intended to represent the abstract type.
-        lifetime : str
-            A string indicating the service lifetime, used in error messages.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the class is not abstract.
-        """
-        try:
-            ReflectionAbstract.ensureIsAbstractClass(abstract)
-        except Exception as e:
-            raise OrionisContainerTypeError(
-                f"Unexpected error registering {lifetime} service: {e}"
-            ) from e
-
-# Exported singleton instance
-IsAbstractClass = __IsAbstractClass()

orionis-0.663.0/orionis/container/validators/is_callable.py

@@ -1,30 +0,0 @@
-from typing import Any
-from orionis.container.exceptions import OrionisContainerTypeError
-
-class __IsCallable:
-    """
-    Validator that checks if a value is callable.
-    Can be used directly like a function: `IsCallable(value)`
-    """
-
-    def __call__(self, value: Any) -> None:
-        """
-        Ensures that the provided value is callable.
-
-        Parameters
-        ----------
-        value : Any
-            The value to check.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the value is not callable.
-        """
-        if not callable(value):
-            raise OrionisContainerTypeError(
-                f"Expected a callable type, but got {type(value).__name__} instead."
-            )
-
-# Exported singleton instance
-IsCallable = __IsCallable()

orionis-0.663.0/orionis/container/validators/is_concrete_class.py

@@ -1,34 +0,0 @@
-from typing import Callable, Any
-from orionis.services.introspection.concretes.reflection import ReflectionConcrete
-from orionis.container.exceptions import OrionisContainerTypeError
-
-class __IsConcreteClass:
-    """
-    Validator that ensures a class is a concrete (non-abstract) class.
-    """
-
-    def __call__(self, concrete: Callable[..., Any], lifetime: str) -> None:
-        """
-        Ensures that the provided class is a concrete (non-abstract) class.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The class intended to represent the concrete implementation.
-        lifetime : str
-            A string indicating the service lifetime, used in error messages.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the class is abstract or invalid.
-        """
-        try:
-            ReflectionConcrete.ensureIsConcreteClass(concrete)
-        except Exception as e:
-            raise OrionisContainerTypeError(
-                f"Unexpected error registering {lifetime} service: {e}"
-            ) from e
-
-# Exported singleton instance
-IsConcreteClass = __IsConcreteClass()

orionis-0.663.0/orionis/container/validators/is_instance.py

@@ -1,32 +0,0 @@
-from typing import Any
-from orionis.services.introspection.instances.reflection import ReflectionInstance
-from orionis.container.exceptions import OrionisContainerTypeError
-
-class __IsInstance:
-    """
-    Validator that ensures the provided object is a valid instance (not a class or abstract type).
-    """
-
-    def __call__(self, instance: Any) -> None:
-        """
-        Ensures that the provided object is a valid instance.
-
-        Parameters
-        ----------
-        instance : Any
-            The object to be validated.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the object is not a valid instance.
-        """
-        try:
-            ReflectionInstance.ensureIsInstance(instance)
-        except Exception as e:
-            raise OrionisContainerTypeError(
-                f"Error registering instance: {e}"
-            ) from e
-
-# Exported singleton instance
-IsInstance = __IsInstance()

orionis-0.663.0/orionis/container/validators/is_not_subclass.py

@@ -1,32 +0,0 @@
-from typing import Callable
-from orionis.container.exceptions import OrionisContainerException
-
-class __IsNotSubclass:
-    """
-    Validator that ensures a class is NOT a subclass of another class.
-    """
-
-    def __call__(self, abstract: Callable[..., any], concrete: Callable[..., any]) -> None:
-        """
-        Validates that the concrete class is NOT a subclass of the abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The supposed base class or interface.
-        concrete : Callable[..., Any]
-            The implementation class to check.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the concrete class IS a subclass of the abstract class.
-        """
-        if issubclass(concrete, abstract):
-            raise OrionisContainerException(
-                "The concrete class must NOT inherit from the provided abstract class. "
-                "Please ensure that the concrete class is not a subclass of the specified abstract class."
-            )
-
-# Exported singleton instance
-IsNotSubclass = __IsNotSubclass()

orionis-0.663.0/orionis/container/validators/is_subclass.py

@@ -1,32 +0,0 @@
-from typing import Callable
-from orionis.container.exceptions import OrionisContainerException
-
-class __IsSubclass:
-    """
-    Validator that ensures a class is a subclass of a given abstract class.
-    """
-
-    def __call__(self, abstract: Callable[..., any], concrete: Callable[..., any]) -> None:
-        """
-        Validates that the concrete class is a subclass of the abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The base or abstract class.
-        concrete : Callable[..., Any]
-            The class to verify.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the concrete class is NOT a subclass of the abstract class.
-        """
-        if not issubclass(concrete, abstract):
-            raise OrionisContainerException(
-                "The concrete class must inherit from the provided abstract class. "
-                "Please ensure that the concrete class is a subclass of the specified abstract class."
-            )
-
-# Exported singleton instance
-IsSubclass = __IsSubclass()

orionis-0.663.0/orionis/container/validators/is_valid_alias.py

@@ -1,42 +0,0 @@
-from typing import Any
-from orionis.container.exceptions import OrionisContainerTypeError
-
-class __IsValidAlias:
-    """
-    Validator that checks if a value is a valid alias string.
-    """
-
-    _INVALID_CHARS = set(' \t\n\r\x0b\x0c!@#$%^&*()[]{};:,/<>?\\|`~"\'')
-
-    def __call__(self, value: Any) -> None:
-        """
-        Ensures that the provided value is a valid alias of type str and does not contain invalid characters.
-
-        Parameters
-        ----------
-        value : Any
-            The value to check.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the value is not of type str or contains invalid characters.
-        """
-        if value is None or value == "" or str(value).isspace():
-            raise OrionisContainerTypeError(
-                "Alias cannot be None, empty, or whitespace only."
-            )
-
-        if not isinstance(value, str):
-            raise OrionisContainerTypeError(
-                f"Expected a string type for alias, but got {type(value).__name__} instead."
-            )
-
-        if any(char in self._INVALID_CHARS for char in value):
-            raise OrionisContainerTypeError(
-                f"Alias '{value}' contains invalid characters. "
-                "Aliases must not contain whitespace or special symbols."
-            )
-
-# Exported singleton instance
-IsValidAlias = __IsValidAlias()

orionis-0.663.0/orionis/container/validators/lifetime.py

@@ -1,53 +0,0 @@
-from typing import Any, Union
-from orionis.container.enums.lifetimes import Lifetime
-from orionis.container.exceptions import OrionisContainerTypeError
-
-class __LifetimeValidator:
-    """
-    Validator that checks if a value is a valid lifetime and converts string representations
-    to Lifetime enum values.
-    """
-
-    def __call__(self, lifetime: Union[str, Lifetime, Any]) -> Lifetime:
-        """
-        Validates and normalizes the provided lifetime value.
-
-        Parameters
-        ----------
-        lifetime : Union[str, Lifetime, Any]
-            The lifetime value to validate. Can be a Lifetime enum or a string
-            representing a valid lifetime.
-
-        Returns
-        -------
-        Lifetime
-            The validated Lifetime enum value.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the value is not a valid Lifetime enum or string representation,
-            or if the string doesn't match any valid Lifetime value.
-        """
-        # Already a Lifetime enum
-        if isinstance(lifetime, Lifetime):
-            return lifetime
-
-        # String that might represent a Lifetime
-        if isinstance(lifetime, str):
-            lifetime_key = lifetime.strip().upper()
-            if lifetime_key in Lifetime.__members__:
-                return Lifetime[lifetime_key]
-
-            valid_options = ', '.join(Lifetime.__members__.keys())
-            raise OrionisContainerTypeError(
-                f"Invalid lifetime '{lifetime}'. Valid options are: {valid_options}."
-            )
-
-        # Invalid type
-        raise OrionisContainerTypeError(
-            f"Lifetime must be of type str or Lifetime enum, got {type(lifetime).__name__}."
-        )
-
-# Exported singleton instance
-LifetimeValidator = __LifetimeValidator()