orionis 0.139.0__tar.gz → 0.151.0__tar.gz

{orionis-0.139.0/orionis.egg-info → orionis-0.151.0}/PKG-INFO

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

{orionis-0.139.0 → orionis-0.151.0}/orionis/framework.py

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

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/base/command.py

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.console.base.i_command import IBaseCommand
+from orionis.luminate.contracts.console.base.command import IBaseCommand
 from orionis.luminate.console.output.console import Console
 from orionis.luminate.console.output.progress_bar import ProgressBar
 
@@ -8,9 +8,12 @@ class BaseCommand(IBaseCommand):
     various types (success, info, warning, etc.) in different styles (e.g., text, bold, colored).
 
     This class acts as a foundation for command classes, offering utility methods to interact with the console.
-    """
 
-    # Command arguments
+    Parameters
+    ----------
+    args : dict, optional
+        A dictionary containing the command arguments (default is an empty dictionary).
+    """
     args = {}
 
     def success(self, message: str = '', timestamp: bool = True):

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/command_filter.py

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.console.i_command_filter import ICommandFilter
+from orionis.luminate.contracts.console.command_filter import ICommandFilter
 
 # List of commands to exclude from output formatting
 EXCLUDED_COMMANDS = [

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/commands/cache_clear.py

@@ -44,9 +44,10 @@ class CacheClearCommand(BaseCommand):
             # Recursively traverse directories starting from the base path
             for root, dirs, files in os.walk(base_path, topdown=True):
 
-                # Skip the 'venv' directory and its subdirectories
-                if 'venv' in dirs:
-                    dirs.remove('venv')
+                # Skip common environment directories (e.g., venv, env, vendor, node_modules)
+                for env_dir in ['venv', 'env', 'virtualenv', 'venv3', 'env3', 'venv2', 'env2', 'vendor', 'node_modules', 'environment']:
+                    if env_dir in dirs:
+                        dirs.remove(env_dir)
 
                 # Check for __pycache__ directories
                 if '__pycache__' in dirs:

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/commands/schedule_work.py

@@ -1,7 +1,7 @@
 import importlib
 from orionis.luminate.console.base.command import BaseCommand
 from orionis.luminate.console.exceptions.cli_exception import CLIOrionisRuntimeError
-from orionis.luminate.contracts.console.i_task_manager import ITaskManager
+from orionis.luminate.contracts.console.task_manager import ITaskManager
 from orionis.luminate.facades.commands.scheduler_facade import Schedule
 
 

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/kernel.py

@@ -1,6 +1,5 @@
 from typing import Any
-from orionis.luminate.contracts.console.i_kernel import ICLIKernel
-from orionis.luminate.console.runner import CLIRunner
+from orionis.luminate.contracts.console.kernel import ICLIKernel
 
 class CLIKernel(ICLIKernel):
     """

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/output/console.py

@@ -2,7 +2,7 @@ import os
 import sys
 import getpass
 import datetime
-from orionis.luminate.contracts.console.output.i_console import IConsole
+from orionis.luminate.contracts.console.output.console import IConsole
 from orionis.luminate.console.output.styles import ANSIColors
 from orionis.luminate.support.exception_to_dict import ExceptionsToDict
 

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/output/executor.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from orionis.luminate.contracts.console.output.i_executor import IExecutor
+from orionis.luminate.contracts.console.output.executor import IExecutor
 from orionis.luminate.console.output.styles import ANSIColors
 
 class Executor(IExecutor):

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/output/progress_bar.py

@@ -1,5 +1,5 @@
 import sys
-from orionis.luminate.contracts.console.output.i_progress_bar import IProgressBar
+from orionis.luminate.contracts.console.output.progress_bar import IProgressBar
 
 class ProgressBar(IProgressBar):
     """

{orionis-0.139.0 → orionis-0.151.0}/orionis/luminate/console/parser.py

@@ -3,7 +3,7 @@ import types
 import argparse
 from contextlib import redirect_stderr
 from io import StringIO
-from orionis.luminate.contracts.console.i_parser import IParser
+from orionis.luminate.contracts.console.parser import IParser
 
 class Parser(IParser):
     """

orionis-0.151.0/orionis/luminate/container/container.py

@@ -0,0 +1,567 @@
+import inspect
+from threading import Lock
+from typing import Callable, Any, Dict, Deque, Optional, Type, get_origin, get_args
+from collections import deque
+from orionis.luminate.container.container_integrity import ContainerIntegrity
+from orionis.luminate.container.lifetimes import Lifetime
+from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerValueError, OrionisContainerTypeError
+from orionis.luminate.contracts.container.container import IContainer
+
+class Container(IContainer):
+    """
+    Service container and dependency injection manager.
+
+    This class follows the singleton pattern to manage service bindings, instances,
+    and different lifecycle types such as transient, singleton, and scoped.
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    @classmethod
+    def destroy(cls):
+        """
+        Destroys the current instance of the container.
+
+        This method resets the singleton instance, effectively clearing all registered
+        services and instances.
+
+        Examples
+        --------
+        >>> Container.destroy()
+        """
+        cls._instance = None
+
+    @classmethod
+    def reset(cls):
+        """
+        Resets the container to its initial state.
+
+        This method destroys the current instance and immediately creates a new one.
+
+        Examples
+        --------
+        >>> Container.reset()
+        """
+        cls._instance = None
+        super().__new__(cls)
+
+    def __new__(cls):
+        """
+        Create a new instance of the container.
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._scoped_instances = {}
+                    cls._instance._singleton_instances = {}
+                    cls._instance._instances_services = {}
+                    cls._instance._transient_services = {}
+                    cls._instance._scoped_services = {}
+                    cls._instance._singleton_services = {}
+                    cls._instance._aliases_services = {}
+        return cls._instance
+
+    def bind(self, abstract: Callable[..., Any], concrete: Callable[..., Any], lifetime: str = Lifetime.TRANSIENT.value) -> None:
+        """
+        Binds an abstract type to a concrete implementation with a specified lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+        lifetime : str
+            The lifecycle of the binding. Must be one of 'transient', 'scoped', or 'singleton'.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If an invalid lifetime is provided or the concrete implementation is None.
+
+        Examples
+        --------
+        >>> container.bind(MyService, MyServiceImplementation, "singleton")
+        """
+
+        if lifetime not in [member.value for member in Lifetime]:
+            raise OrionisContainerValueError(f"Invalid lifetime type '{lifetime}'.")
+
+        if concrete is None:
+            raise OrionisContainerValueError("Concrete implementation cannot be None when binding a service.")
+
+        abstract = abstract or concrete
+        ContainerIntegrity.ensureIsCallable(concrete)
+        ContainerIntegrity.ensureNotMain(concrete)
+
+        service_entry = {
+            "concrete": concrete,
+            "async": inspect.iscoroutinefunction(concrete)
+        }
+
+        service_registry = {
+            Lifetime.TRANSIENT.value: self._transient_services,
+            Lifetime.SCOPED.value: self._scoped_services,
+            Lifetime.SINGLETON.value: self._singleton_services
+        }
+
+        if ContainerIntegrity.isAbstract(abstract):
+            ContainerIntegrity.ensureImplementation(abstract, concrete)
+            service_registry[lifetime][abstract] = service_entry
+            return
+
+        if ContainerIntegrity.isAlias(abstract):
+            service_registry[lifetime][abstract] = service_entry
+            return
+
+        raise OrionisContainerValueError(f"Invalid abstract type '{abstract}'. It must be a valid alias or an abstract class.")
+
+    def transient(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
+        """
+        Registers a service with a transient lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+
+        Examples
+        --------
+        >>> container.transient(MyService, MyServiceImplementation)
+        """
+
+        self.bind(abstract, concrete, Lifetime.TRANSIENT.value)
+
+    def scoped(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
+        """
+        Registers a service with a scoped lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+
+        Examples
+        --------
+        >>> container.scoped(MyService, MyServiceImplementation)
+        """
+
+        self.bind(abstract, concrete, Lifetime.SCOPED.value)
+
+    def singleton(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
+        """
+        Registers a service with a singleton lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+
+        Examples
+        --------
+        >>> container.singleton(MyService, MyServiceImplementation)
+        """
+
+        self.bind(abstract, concrete, Lifetime.SINGLETON.value)
+
+    def instance(self, abstract: Callable[..., Any], instance: Any) -> None:
+        """
+        Registers an already instantiated object in the container.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        instance : Any
+            The instance to be stored.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If the instance is None.
+
+        Examples
+        --------
+        >>> container.instance(MyService, my_service_instance)
+        """
+
+        if instance is None:
+            raise OrionisContainerValueError("The provided instance cannot be None.")
+
+        ContainerIntegrity.ensureIsInstance(instance)
+
+        if ContainerIntegrity.isAbstract(abstract):
+            ContainerIntegrity.ensureImplementation(abstract, instance.__class__)
+            self._instances_services[abstract] = instance
+            return
+
+        if ContainerIntegrity.isAlias(abstract):
+            self._instances_services[abstract] = instance
+            return
+
+        raise OrionisContainerValueError(f"Invalid abstract type '{abstract}'. It must be a valid alias or an abstract class.")
+
+    def bound(self, abstract_or_alias: Callable[..., Any]) -> bool:
+        """
+        Checks if a service or alias is bound in the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Callable[..., Any]
+            The abstract type or alias to check.
+
+        Returns
+        -------
+        bool
+            True if the service is bound, False otherwise.
+
+        Examples
+        --------
+        >>> container.bound(MyService)
+        True
+        """
+
+        service_dicts = [
+            self._instances_services,
+            self._transient_services,
+            self._scoped_services,
+            self._singleton_services,
+            self._aliases_services
+        ]
+        return any(abstract_or_alias in service_dict for service_dict in service_dicts)
+
+    def has(self, abstract_or_alias: Callable[..., Any]) -> bool:
+        """
+        Alias for `bound()` method.
+
+        Parameters
+        ----------
+        abstract_or_alias : Callable[..., Any]
+            The abstract type or alias to check.
+
+        Returns
+        -------
+        bool
+            True if the service is bound, False otherwise.
+
+        Examples
+        --------
+        >>> container.has(MyService)
+        True
+        """
+
+        return self.bound(abstract_or_alias)
+
+    def alias(self, alias: Callable[..., Any], abstract: Callable[..., Any]) -> None:
+        """
+        Creates an alias for an existing abstract binding.
+
+        Parameters
+        ----------
+        alias : Callable[..., Any]
+            The alias name.
+        abstract : Callable[..., Any]
+            The existing abstract type to alias.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If the abstract type is not registered or the alias is already in use.
+
+        Examples
+        --------
+        >>> container.alias("DatabaseService", MyDatabaseService)
+        """
+
+        if not self.has(abstract):
+            raise OrionisContainerValueError(f"Abstract '{abstract}' is not registered in the container.")
+
+        if alias in self._aliases_services:
+            raise OrionisContainerValueError(f"Alias '{alias}' is already in use.")
+
+        if not ContainerIntegrity.isAlias(abstract):
+            raise OrionisContainerValueError(f"Invalid target abstract type: {abstract}. It must be an alias.")
+
+        self._aliases_services[alias] = abstract
+
+    def isAlias(self, name: str) -> bool:
+        """
+        Checks if a given name is an alias.
+
+        Parameters
+        ----------
+        name : str
+            The name to check.
+
+        Returns
+        -------
+        bool
+            True if the name is an alias, False otherwise.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the name is not a string.
+
+        Examples
+        --------
+        >>> container.isAlias("DatabaseService")
+        True
+        """
+
+        if not isinstance(name, str):
+            raise OrionisContainerTypeError("The name must be a valid string.")
+        return name in self._aliases_services
+
+    def getBindings(self) -> Dict[str, Any]:
+        """
+        Retrieves all registered service bindings.
+
+        Returns
+        -------
+        dict
+            A dictionary containing all instances, transient, scoped, singleton, and alias services.
+
+        Examples
+        --------
+        >>> container.getBindings()
+        """
+
+        return {
+            "instances": self._instances_services,
+            "transient": self._transient_services,
+            "scoped": self._scoped_services,
+            "singleton": self._singleton_services,
+            "aliases": self._aliases_services
+        }
+
+    def getAlias(self, name: str) -> Callable[..., Any]:
+        """
+        Retrieves the abstract type associated with an alias.
+
+        Parameters
+        ----------
+        name : str
+            The alias name.
+
+        Returns
+        -------
+        Callable[..., Any]
+            The abstract type associated with the alias.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If the alias is not registered.
+
+        Examples
+        --------
+        >>> container.getAlias("DatabaseService")
+        <class 'MyDatabaseService'>
+        """
+
+        if not isinstance(name, str):
+            raise OrionisContainerValueError("The name must be a valid string.")
+
+        if name not in self._aliases_services:
+            raise OrionisContainerValueError(f"Alias '{name}' is not registered in the container.")
+
+        return self._aliases_services[name]
+
+    def forgetScopedInstances(self) -> None:
+        """
+        Clears all scoped instances.
+
+        Examples
+        --------
+        >>> container.forgetScopedInstances()
+        """
+
+        self._scoped_instances = {}
+
+    def newRequest(self) -> None:
+        """
+        Resets scoped instances to handle a new request.
+
+        Examples
+        --------
+        >>> container.newRequest()
+        """
+
+        self.forgetScopedInstances()
+
+    async def make(self, abstract_or_alias: Callable[..., Any]) -> Any:
+        """
+        Resolves and instantiates a service from the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Callable[..., Any]
+            The abstract type or alias to resolve.
+
+        Returns
+        -------
+        Any
+            The instantiated service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the service is not found.
+
+        Examples
+        --------
+        >>> service = await container.make(MyService)
+        """
+
+        if abstract_or_alias in self._aliases_services:
+            abstract_or_alias = self._aliases_services[abstract_or_alias]
+
+        if abstract_or_alias in self._instances_services:
+            return self._instances_services[abstract_or_alias]
+
+        if abstract_or_alias in self._singleton_services:
+            if abstract_or_alias not in self._singleton_instances:
+                service = self._singleton_services[abstract_or_alias]
+                self._singleton_instances[abstract_or_alias] = await service['concrete']() if service['async'] else service['concrete']()
+            return self._singleton_instances[abstract_or_alias]
+
+        if abstract_or_alias in self._scoped_services:
+            if abstract_or_alias not in self._scoped_instances:
+                service = self._scoped_services[abstract_or_alias]
+                self._scoped_instances[abstract_or_alias] = await service['concrete']() if service['async'] else service['concrete']()
+            return self._scoped_instances[abstract_or_alias]
+
+        if abstract_or_alias in self._transient_services:
+            service = self._transient_services[abstract_or_alias]
+            return await service['concrete']() if service['async'] else service['concrete']()
+
+        raise OrionisContainerException(f"No binding found for '{abstract_or_alias}' in the container.")
+
+    def _resolve(self, concrete: Callable[..., Any], resolving: Optional[Deque[Type]] = None) -> Any:
+        """
+        Resolves dependencies recursively and instantiates a class.
+
+        Parameters
+        ----------
+        concrete : Callable[..., Any]
+            The concrete implementation to instantiate.
+        resolving : Optional[Deque[Type]], optional
+            A queue to track resolving dependencies and prevent circular dependencies.
+
+        Returns
+        -------
+        Any
+            The instantiated object.
+
+        Raises
+        ------
+        OrionisContainerException
+            If circular dependencies are detected or instantiation fails.
+
+        Examples
+        --------
+        >>> instance = container._resolve(MyClass)
+        """
+
+        if resolving is None:
+            resolving = deque()
+
+        if concrete in resolving:
+            raise OrionisContainerException(f"Circular dependency detected for {concrete}.")
+
+        resolving.append(concrete)
+
+        try:
+            signature = inspect.signature(concrete)
+        except ValueError as e:
+            raise OrionisContainerException(f"Unable to inspect signature of {concrete}: {str(e)}")
+
+        resolved_dependencies: Dict[str, Any] = {}
+        unresolved_dependencies = deque()
+
+        for param_name, param in signature.parameters.items():
+            if param_name == 'self':
+                continue
+
+            if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
+                continue
+
+            if param.annotation is param.empty and param.default is param.empty:
+                unresolved_dependencies.append(param_name)
+                continue
+
+            if param.default is not param.empty:
+                resolved_dependencies[param_name] = param.default
+                continue
+
+            if param.annotation is not param.empty:
+                param_type = param.annotation
+
+                if get_origin(param_type) is not None:
+                    param_type = get_args(param_type)[0]
+
+                if isinstance(param_type, type) and not issubclass(param_type, (int, str, bool, float)):
+                    if self.has(param_type):
+                        resolved_dependencies[param_name] = self.make(f"{param_type.__module__}.{param_type.__name__}")
+                    else:
+                        resolved_dependencies[param_name] = self._resolve_dependency(param_type, resolving)
+                else:
+                    resolved_dependencies[param_name] = param_type
+
+        while unresolved_dependencies:
+            dep_name = unresolved_dependencies.popleft()
+            if dep_name not in resolved_dependencies:
+                resolved_dependencies[dep_name] = self._resolve_dependency(dep_name, resolving)
+
+        try:
+            instance = concrete(**resolved_dependencies)
+            resolving.pop()
+            return instance
+        except Exception as e:
+            raise OrionisContainerException(f"Failed to instantiate {concrete}: {str(e)}")
+
+    def _resolve_dependency(self, dep_type: Any, resolving: Optional[Deque[Type]] = None) -> Any:
+        """
+        Resolves a dependency by instantiating or retrieving it from the container.
+
+        Parameters
+        ----------
+        dep_type : Any
+            The dependency type to resolve.
+        resolving : Optional[Deque[Type]], optional
+            A queue to track resolving dependencies.
+
+        Returns
+        -------
+        Any
+            The resolved dependency.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the dependency cannot be resolved.
+
+        Examples
+        --------
+        >>> dependency = container._resolve_dependency(MyDependency)
+        """
+
+        if resolving is None:
+            resolving = deque()
+
+        if isinstance(dep_type, type):
+            if self.has(dep_type):
+                return self.make(f"{dep_type.__module__}.{dep_type.__name__}")
+            else:
+                return self._resolve(dep_type, resolving)
+
+        raise OrionisContainerException(f"Cannot resolve dependency of type {dep_type}")