orionis 0.318.0__py3-none-any.whl → 0.320.0__py3-none-any.whl

orionis/container/contracts/container.py

@@ -0,0 +1,202 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable
+from orionis.container.enums.lifetimes import Lifetime
+
+class IContainer(ABC):
+    """
+    IContainer is an interface that defines the structure for a dependency injection container.
+    It provides methods for registering and resolving services with different lifetimes.
+    """
+
+    @abstractmethod
+    def singleton(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any],
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
+        """
+        Register a service as a singleton.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or interface to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+        alias : str, optional
+            An alternative name to register the service under.
+        enforce_decoupling : bool, optional
+            Whether to enforce that concrete is not a subclass of abstract.
+
+        Returns
+        -------
+        bool
+            True if the service was registered successfully.
+        """
+        pass
+
+    @abstractmethod
+    def transient(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any],
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
+        """
+        Register a service as transient.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or interface to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+        alias : str, optional
+            An alternative name to register the service under.
+        enforce_decoupling : bool, optional
+            Whether to enforce that concrete is not a subclass of abstract.
+
+        Returns
+        -------
+        bool
+            True if the service was registered successfully.
+        """
+        pass
+
+    @abstractmethod
+    def scoped(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any],
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
+        """
+        Register a service as scoped.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or interface to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+        alias : str, optional
+            An alternative name to register the service under.
+        enforce_decoupling : bool, optional
+            Whether to enforce that concrete is not a subclass of abstract.
+
+        Returns
+        -------
+        bool
+            True if the service was registered successfully.
+        """
+        pass
+
+    @abstractmethod
+    def instance(
+        self,
+        abstract: Callable[..., Any],
+        instance: Any,
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
+        """
+        Register an instance of a service.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract class or interface to associate with the instance.
+        instance : Any
+            The concrete instance to register.
+        alias : str, optional
+            An optional alias to register the instance under.
+        enforce_decoupling : bool, optional
+            Whether to enforce that instance's class is not a subclass of abstract.
+
+        Returns
+        -------
+        bool
+            True if the instance was successfully registered.
+        """
+        pass
+
+    @abstractmethod
+    def function(
+        self,
+        alias: str,
+        fn: Callable[..., Any],
+        *,
+        lifetime: Lifetime = Lifetime.TRANSIENT
+    ) -> bool:
+        """
+        Register a function as a service.
+
+        Parameters
+        ----------
+        alias : str
+            The alias to register the function under.
+        fn : Callable[..., Any]
+            The function or factory to register.
+        lifetime : Lifetime, optional
+            The lifetime of the function registration (default is TRANSIENT).
+
+        Returns
+        -------
+        bool
+            True if the function was registered successfully.
+        """
+        pass
+
+    @abstractmethod
+    def make(
+        self,
+        abstract_or_alias: Any,
+        *args: tuple,
+        **kwargs: dict
+    ) -> Any:
+        """
+        Resolve a service from the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Any
+            The abstract class, interface, or alias (str) to resolve.
+        *args : tuple
+            Positional arguments to pass to the constructor.
+        **kwargs : dict
+            Keyword arguments to pass to the constructor.
+
+        Returns
+        -------
+        Any
+            An instance of the requested service.
+        """
+        pass
+
+    @abstractmethod
+    def bound(
+        self,
+        abstract_or_alias: Any
+    ) -> bool:
+        """
+        Check if a service is registered in the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Any
+            The abstract class, interface, or alias (str) to check.
+
+        Returns
+        -------
+        bool
+            True if the service is registered, False otherwise.
+        """
+        pass

orionis/container/resolver.py

@@ -0,0 +1,28 @@
+from orionis.container.contracts.container import IContainer
+from orionis.container.entities.binding import Binding
+from orionis.container.enums.lifetimes import Lifetime
+
+
+class Resolver:
+    """
+    Resolver class for handling dependency resolution in the container.
+    """
+
+    def __init__(
+        self,
+        container:IContainer,
+        lifetime:Lifetime
+    ):
+        self.container = container
+        self.lifetime = lifetime
+
+    def transient(
+        self,
+        binding:Binding,
+        *args,
+        **kwargs
+    ):
+        """
+        Register a transient service.
+        """
+        return self.container.transient(service, implementation, **kwargs)

orionis/container/validators/implements.py

@@ -0,0 +1,67 @@
+from typing import Callable, Any
+from orionis.services.introspection.reflection import Reflection
+from orionis.container.exceptions.container_exception 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.
+        """
+        if abstract is None:
+            raise OrionisContainerException("Abstract class must be provided for implementation check.")
+
+        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."
+            )
+
+        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.")
+
+        target_class = target if Reflection.isClass(target) else target.__class__
+        target_name = target_class.__name__
+        abstract_name = abstract.__name__
+
+        not_implemented = []
+        for method in abstract_methods:
+            # Considera métodos renombrados en clases concretas (_Abstract.m → _Concrete.m)
+            expected_method = str(method).replace(f"_{abstract_name}", f"_{target_name}")
+            if not hasattr(target, expected_method):
+                not_implemented.append(method)
+
+        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/container/validators/is_abstract_class.py

@@ -0,0 +1,34 @@
+from typing import Callable, Any
+from orionis.services.introspection.abstract.reflection_abstract import ReflectionAbstract
+from orionis.container.exceptions.type_error_exception 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/container/validators/is_callable.py

@@ -0,0 +1,30 @@
+from typing import Any
+from orionis.container.exceptions.type_error_exception 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/container/validators/is_concrete_class.py

@@ -0,0 +1,34 @@
+from typing import Callable, Any
+from orionis.services.introspection.concretes.reflection_concrete import ReflectionConcrete
+from orionis.container.exceptions.type_error_exception 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/container/validators/is_instance.py

@@ -0,0 +1,32 @@
+from typing import Any
+from orionis.services.introspection.instances.reflection_instance import ReflectionInstance
+from orionis.container.exceptions.type_error_exception 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/container/validators/is_not_subclass.py

@@ -0,0 +1,32 @@
+from typing import Callable
+from orionis.container.exceptions.container_exception 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/container/validators/is_subclass.py

@@ -0,0 +1,32 @@
+from typing import Callable
+from orionis.container.exceptions.container_exception 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/container/validators/is_valid_alias.py

@@ -0,0 +1,37 @@
+from typing import Any
+from orionis.container.exceptions.type_error_exception 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 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/metadata/framework.py

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

orionis/services/introspection/callables/reflection_callable.py

@@ -130,6 +130,20 @@ class ReflectionCallable:
             return Coroutine(self.__function(*args, **kwargs)).run()
         return self.__function(*args, **kwargs)
 
+    def getSignature(self) -> inspect.Signature:
+        """
+        Retrieve the signature of the callable function.
+        Returns
+        -------
+        inspect.Signature
+            An `inspect.Signature` object representing the callable's signature.
+        Notes
+        -----
+        This method provides detailed information about the parameters of the callable,
+        including their names, default values, and annotations.
+        """
+        return inspect.signature(self.__function)
+
     def getDependencies(self) -> CallableDependency:
         """
         Analyzes the callable associated with this instance and retrieves its dependencies.

orionis/services/introspection/concretes/reflection_concrete.py

@@ -1442,6 +1442,17 @@ class ReflectionConcrete(IReflectionConcrete):
 
         return prop.fget.__doc__ if prop.fget else None
 
+    def getConstructorSignature(self) -> inspect.Signature:
+        """
+        Get the signature of the constructor of the instance's class.
+
+        Returns
+        -------
+        inspect.Signature
+            The signature of the constructor
+        """
+        return inspect.signature(self._concrete.__init__)
+
     def getConstructorDependencies(self) -> ClassDependency:
         """
         Get the resolved and unresolved dependencies from the constructor of the instance's class.

{orionis-0.318.0.dist-info → orionis-0.320.0.dist-info}/METADATA

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

{orionis-0.318.0.dist-info → orionis-0.320.0.dist-info}/RECORD

@@ -135,12 +135,23 @@ orionis/console/output/console.py,sha256=TE_Hl720ADd82dbERFSWhkoQRukDQZmETSw4nkw
 orionis/console/output/executor.py,sha256=bdvkzW2-buy0BPpy2r5qUGrRFW2Ay6k-5rSeHb0gQ3o,3352
 orionis/console/output/progress_bar.py,sha256=vFy582z6VJS46LV6tuyrmr9qvdVeTEtw3hyNcEHezeg,3088
 orionis/console/output/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
-orionis/container/container.py,sha256=TNnevmbvK2e664bl8r1HYk5CHGDsP9J9N_3ZuAHKb6c,30105
+orionis/container/container.py,sha256=HHEXnObv1Q_022dfGpTOx6cwyRPa7ooD8FfqJ_cDCro,37291
+orionis/container/resolver.py,sha256=9nojqjrYYXw2kQUzyuLkHs-os5dDxq6ntZ8e8IbYIu0,704
+orionis/container/contracts/container.py,sha256=LkZ5til_3Um8ctCVTwuO36HkysL59saKwUzXR5cWUBs,5750
 orionis/container/entities/binding.py,sha256=Qp6Lf4XUDp2NjqXDAC2lzvhOFQWiBDKiGFcKfwb4axw,4342
 orionis/container/enums/lifetimes.py,sha256=RqQmugMIB1Ev_j_vFLcWorndm-to7xg4stQ7yKFDdDw,190
 orionis/container/exceptions/container_exception.py,sha256=goTDEwC70xTMD2qppN8KV-xyR0Nps218OD4D1LZ2-3s,470
 orionis/container/exceptions/type_error_exception.py,sha256=cYuvoXVOgRYj3tZPfK341aUERkf33-buOiI2eXxcrAw,470
 orionis/container/exceptions/value_exception.py,sha256=hjY0YEusoL3DurME1ornxvIv1wyGaf6tBggLFlGHblo,472
+orionis/container/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/container/validators/implements.py,sha256=iSoDxxTalQKhyKjvsojFlkROhBFvAjvJxRvPJlmGrSg,2843
+orionis/container/validators/is_abstract_class.py,sha256=Q-Lqyrrps6oj2XWI0KFRp-hDZf4_sgbZlEbfBXj5XT4,1169
+orionis/container/validators/is_callable.py,sha256=8Bi5AflNmXhpgtk1ieirE3xgCKzq3mcgyqokCU3GHN8,843
+orionis/container/validators/is_concrete_class.py,sha256=BMhJ7vCQ2ccBA3qrRJPlsYDTSqBpqLZFfrdEGO5mlr4,1215
+orionis/container/validators/is_instance.py,sha256=vUwWIMeG1zLMsGX9GyoOU-LZtCgqBDZ9hUNDj_KyuYo,999
+orionis/container/validators/is_not_subclass.py,sha256=-iZw5ZCYnQtlU-xPO-o7lUj5DxPkN0G67-bLbLVhwtw,1167
+orionis/container/validators/is_subclass.py,sha256=O2aF0KLg5ZnDutKQ1xDvet34kentftlqgEkRNvumCoM,1135
+orionis/container/validators/is_valid_alias.py,sha256=avm6uz-huVi_kRov4BksSToslIHQfz-MLynjkzhdSRM,1246
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/startup.py,sha256=JKAH2ZRhlAZgkD2w11LR1-TVktfjSH9cHo3PsZXOLrg,8275
@@ -232,7 +243,7 @@ orionis/foundation/contracts/config.py,sha256=Rpz6U6t8OXHO9JJKSTnCimytXE-tfCB-1i
 orionis/foundation/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/exceptions/integrity.py,sha256=mc4pL1UMoYRHEmphnpW2oGk5URhu7DJRREyzHaV-cs8,472
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=W5PbEW1Zw29V6NsVuzd9ZafK7iR0638kO2Jm0wIwNGw,4960
+orionis/metadata/framework.py,sha256=sBQIEDehFdisleRXQSFyOhHx2bVTGjprHNNBI_Famsw,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -259,9 +270,9 @@ orionis/services/introspection/reflection.py,sha256=6z4VkDICohMIkm9jEd7nmFABwVuU
 orionis/services/introspection/abstract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/abstract/reflection_abstract.py,sha256=SPK2X11VvGORxxPOYloaD6hPAvky--obRU4CO1DE4zM,43865
 orionis/services/introspection/callables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/callables/reflection_callable.py,sha256=wjztKcqXIT4J-LPXK_Iszv-VzqHoT9MLp0n-GDMtmgA,5633
+orionis/services/introspection/callables/reflection_callable.py,sha256=0B2B6ZV-ql_aZk97W4Q12MVvi0gwErjekgWaMBxjfV0,6147
 orionis/services/introspection/concretes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/concretes/reflection_concrete.py,sha256=1GxD-y8LPGL6kI4Y3XbeLcFjR5Y8cOqbVEPCtPnsuYA,50982
+orionis/services/introspection/concretes/reflection_concrete.py,sha256=SdE2IWEgt30eO9-f_VRNdIZ_OWWidauQzQZQVrXjcXY,51310
 orionis/services/introspection/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/contracts/reflect_dependencies.py,sha256=5fdImZarC1ixoFM-1JSBx28RvYbY3GGZhDGjar7cvHc,1771
 orionis/services/introspection/contracts/reflection_abstract.py,sha256=-ugpFcAkGTlk0Md5ft8NrvupnlfVji8QZjGYqWBxqeY,22370
@@ -344,7 +355,7 @@ orionis/test/suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 orionis/test/suite/test_unit.py,sha256=MWgW8dRCRyT1XZ5LsbXQ7-KVPReasoXwzEEL1EWWfE4,52190
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=jXZkbITBknbUwm_mD8bcTiwLDvsFkrO9qrf0ZgPwqxc,4903
-orionis-0.318.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.320.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=kvWgiW3ADEZf718dGsMPtDh_rmOSx1ypEInKm7_6ZPQ,601
@@ -445,8 +456,8 @@ tests/support/wrapper/test_services_wrapper_docdict.py,sha256=yeVwl-VcwkWSQYyxZu
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=MrGK3ZimedL0b5Ydu69Dg8Iul017AzLTm7VPxpXlpfU,4315
 tests/testing/test_testing_unit.py,sha256=DjLBtvVn8B1KlVJNNkstBT8_csA1yeaMqnGrbanN_J4,7438
-orionis-0.318.0.dist-info/METADATA,sha256=_bC7iHlD1eWAOWCuGO8KoLXLlrBz_2nEO7fsbBa2uvI,4772
-orionis-0.318.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.318.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.318.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.318.0.dist-info/RECORD,,
+orionis-0.320.0.dist-info/METADATA,sha256=J4HkjZk_1Wa2wuK0UZboolNPepT3CA4uflTNQrXlGk0,4772
+orionis-0.320.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+orionis-0.320.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.320.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.320.0.dist-info/RECORD,,