orionis 0.405.0__tar.gz → 0.406.0__tar.gz

{orionis-0.405.0/orionis.egg-info → orionis-0.406.0}/PKG-INFO

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

orionis-0.406.0/orionis/console/base/command.py

@@ -0,0 +1,92 @@
+from typing import Any, Dict
+from orionis.console.dynamic.progress_bar import ProgressBar
+from orionis.console.output.console import Console
+from orionis.console.base.contracts.command import IBaseCommand
+
+class BaseCommand(Console, ProgressBar, IBaseCommand):
+    """
+    Abstract base class for console commands in Orionis.
+
+    Inherits from Console and ProgressBar, allowing commands to:
+    - Display messages, errors, and formatted text in the console.
+    - Manage progress bars for long-running tasks.
+    - Access and manipulate parsed arguments from the command line.
+
+    Attributes
+    ----------
+    args : dict
+        Dictionary containing the parsed arguments for the command. Set via the setArgs method.
+
+    Methods
+    -------
+    handle()
+        Must be implemented by each subclass to define the main logic of the command.
+    argument(key)
+        Retrieves the value of a specific argument by key.
+    arguments()
+        Returns all parsed arguments as a dictionary.
+    """
+
+    args: Dict[str, Any] = {}
+
+    def handle(self):
+        """
+        Main entry point for command execution.
+
+        This method must be overridden in each subclass to define the specific logic of the command.
+        Access parsed arguments via self.args and use console and progress bar methods as needed.
+
+        Example:
+            def handle(self):
+                self.write("Processing...")
+                value = self.argument("key")
+                # custom logic
+
+        Raises
+        ------
+        NotImplementedError
+            Always raised in the base class. Subclasses must implement this method.
+        """
+        raise NotImplementedError("The 'handle' method must be implemented in the subclass.")
+
+    def argument(self, key: str):
+        """
+        Retrieves the value of a specific argument by its key.
+
+        Parameters
+        ----------
+        key : str
+            Name of the argument to retrieve.
+
+        Returns
+        -------
+        any or None
+            Value associated with the key, or None if it does not exist or arguments are not set.
+
+        Raises
+        ------
+        ValueError
+            If the key is not a string or if arguments are not a dictionary.
+
+        Example:
+            value = self.argument("user")
+        """
+        if not isinstance(key, str):
+            raise ValueError("Argument key must be a string.")
+        if not isinstance(self.args, dict):
+            raise ValueError("Arguments must be a dictionary.")
+        return self.args.get(key)
+
+    def arguments(self) -> dict:
+        """
+        Returns all parsed arguments as a dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary containing all arguments received by the command. If no arguments, returns an empty dictionary.
+
+        Example:
+            args = self.arguments()
+        """
+        return dict(self.args) if isinstance(self.args, dict) else {}

orionis-0.406.0/orionis/console/base/contracts/command.py

@@ -0,0 +1,68 @@
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class IBaseCommand(ABC):
+    """
+    Abstract base contract for console commands in Orionis.
+
+    Inherits from ABC and defines the required interface for all console commands:
+    - Stores parsed command-line arguments.
+    - Requires implementation of main execution logic and argument accessors.
+
+    Attributes
+    ----------
+    args : Dict[str, Any]
+        Dictionary containing the parsed arguments for the command. Should be set by the command parser.
+    """
+
+    args: Dict[str, Any] = {}
+
+    @abstractmethod
+    def handle(self):
+        """
+        Main entry point for command execution.
+
+        This method must be overridden in each subclass to define the specific logic of the command.
+        Access parsed arguments via self.args and use console/output methods as needed.
+
+        Raises
+        ------
+        NotImplementedError
+            Always raised in the base class. Subclasses must implement this method.
+        """
+        pass
+
+    @abstractmethod
+    def argument(self, key: str) -> Any:
+        """
+        Retrieves the value of a specific argument by its key.
+
+        Parameters
+        ----------
+        key : str
+            Name of the argument to retrieve.
+
+        Returns
+        -------
+        Any or None
+            Value associated with the key, or None if it does not exist or arguments are not set.
+
+        Raises
+        ------
+        ValueError
+            If the key is not a string or if arguments are not a dictionary.
+        """
+        pass
+
+    @abstractmethod
+    def arguments(self) -> Dict[str, Any]:
+        """
+        Returns all parsed arguments as a dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary containing all arguments received by the command. If no arguments, returns an empty dictionary.
+        """
+        pass

{orionis-0.405.0 → orionis-0.406.0}/orionis/console/dynamic/contracts/progress_bar.py

@@ -19,7 +19,7 @@ class IProgressBar(ABC):
     """
 
     @abstractmethod
-    def start(self):
+    def start(self) -> None:
         """
         Initializes the progress bar.
 
@@ -34,7 +34,7 @@ class IProgressBar(ABC):
         pass
 
     @abstractmethod
-    def advance(self, increment: int):
+    def advance(self, increment: int) -> None:
         """
         Advances the progress bar by a given increment.
 
@@ -51,7 +51,7 @@ class IProgressBar(ABC):
         pass
 
     @abstractmethod
-    def finish(self):
+    def finish(self) -> None:
         """
         Completes the progress bar.
 

{orionis-0.405.0 → orionis-0.406.0}/orionis/console/dynamic/progress_bar.py

@@ -34,7 +34,7 @@ class ProgressBar(IProgressBar):
         Completes the progress bar and moves to a new line.
     """
 
-    def __init__(self, total=100, width=50):
+    def __init__(self, total=100, width=50) -> None:
         """
         Constructs all the necessary attributes for the progress bar object.
 
@@ -49,7 +49,7 @@ class ProgressBar(IProgressBar):
         self.bar_width = width
         self.progress = 0
 
-    def _update_bar(self):
+    def __updateBar(self) -> None:
         """
         Updates the visual representation of the progress bar.
 
@@ -64,16 +64,16 @@ class ProgressBar(IProgressBar):
         sys.stdout.write("\r" + bar)
         sys.stdout.flush()
 
-    def start(self):
+    def start(self) -> None:
         """
         Initializes the progress bar to the starting state.
 
         This method resets the progress to zero and displays the initial bar.
         """
         self.progress = 0
-        self._update_bar()
+        self.__updateBar()
 
-    def advance(self, increment=1):
+    def advance(self, increment=1) -> None:
         """
         Advances the progress bar by a specific increment.
 
@@ -85,9 +85,9 @@ class ProgressBar(IProgressBar):
         self.progress += increment
         if self.progress > self.total:
             self.progress = self.total
-        self._update_bar()
+        self.__updateBar()
 
-    def finish(self):
+    def finish(self) -> None:
         """
         Completes the progress bar.
 
@@ -95,6 +95,6 @@ class ProgressBar(IProgressBar):
         and moves the cursor to a new line for cleaner output.
         """
         self.progress = self.total
-        self._update_bar()
+        self.__updateBar()
         sys.stdout.write("\n")
         sys.stdout.flush()

{orionis-0.405.0 → orionis-0.406.0}/orionis/console/output/console.py

@@ -537,7 +537,10 @@ class Console(IConsole):
         """
         if message:
             self.success(message)
-        sys.exit(0)
+        try:
+            sys.exit(0)
+        except SystemExit:
+            os._exit(0)
 
     def exitError(self, message: str = None) -> None:
         """
@@ -550,4 +553,7 @@ class Console(IConsole):
         """
         if message:
             self.error(message)
-        sys.exit(1)
+        try:
+            sys.exit(0)
+        except SystemExit:
+            os._exit(0)

{orionis-0.405.0 → orionis-0.406.0}/orionis/console/output/contracts/console.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List, Union, Optional
+from typing import List, Optional
 
 class IConsole(ABC):
     """

{orionis-0.405.0 → orionis-0.406.0}/orionis/container/container.py

@@ -32,8 +32,8 @@ class Container(IContainer):
         """
         Creates and returns a singleton instance for each specific class.
 
-        This method implements a truly thread-safe singleton pattern with proper 
-        inheritance support, ensuring that each class in the hierarchy has its own 
+        This method implements a truly thread-safe singleton pattern with proper
+        inheritance support, ensuring that each class in the hierarchy has its own
         singleton instance. Uses double-checked locking with proper memory barriers.
 
         Returns

{orionis-0.405.0 → orionis-0.406.0}/orionis/container/context/scope.py

@@ -4,7 +4,10 @@ class ScopedContext:
     """
     Holds scoped instances for the current context.
     """
-    _active_scope = contextvars.ContextVar("orionis_scope", default=None)
+    _active_scope = contextvars.ContextVar(
+        "orionis_scope",
+        default=None
+    )
 
     @classmethod
     def getCurrentScope(cls):

{orionis-0.405.0 → orionis-0.406.0}/orionis/container/contracts/service_provider.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 class IServiceProvider(ABC):
 
     @abstractmethod
-    def register(self) -> None:
+    async def register(self) -> None:
         """
         Register services into the application container.
 
@@ -19,7 +19,7 @@ class IServiceProvider(ABC):
         pass
 
     @abstractmethod
-    def boot(self) -> None:
+    async def boot(self) -> None:
         """
         Perform any post-registration bootstrapping or initialization.
 

orionis-0.406.0/orionis/container/entities/binding.py

@@ -0,0 +1,111 @@
+from dataclasses import dataclass, field
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.container.exceptions import OrionisContainerTypeError
+from orionis.support.entities.base import BaseEntity
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Binding(BaseEntity):
+
+    contract: type = field(
+        default=None,
+        metadata={
+            "description": "Contract of the concrete class to inject.",
+            "default": None
+        }
+    )
+
+    concrete: type = field(
+        default=None,
+        metadata={
+            "description": "Concrete class implementing the contract.",
+            "default": None
+        }
+    )
+
+    instance: object = field(
+        default=None,
+        metadata={
+            "description": "Concrete instance of the class, if provided.",
+            "default": None
+        }
+    )
+
+    function: callable = field(
+        default=None,
+        metadata={
+            "description": "Function invoked to create the instance.",
+            "default": None
+        }
+    )
+
+    lifetime: Lifetime = field(
+        default=Lifetime.TRANSIENT,
+        metadata={
+            "description": "Lifetime of the instance.",
+            "default": Lifetime.TRANSIENT
+        }
+    )
+
+    enforce_decoupling: bool = field(
+        default=False,
+        metadata={
+            "description": "Indicates whether to enforce decoupling between contract and concrete.",
+            "default": False
+        }
+    )
+
+    alias: str = field(
+        default=None,
+        metadata={
+            "description": "Alias for resolving the dependency from the container.",
+            "default": None
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validates the types of specific instance attributes after object initialization.
+
+        This method ensures that:
+        - The 'lifetime' attribute is an instance of the `Lifetime` enum.
+        - The 'enforce_decoupling' attribute is a boolean.
+        - The 'alias' attribute is either a string or None.
+
+        If any of these conditions are not met, an `OrionisContainerTypeError` is raised to prevent improper usage.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It raises an exception if validation fails.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If 'lifetime' is not an instance of `Lifetime`.
+        OrionisContainerTypeError
+            If 'enforce_decoupling' is not of type `bool`.
+        OrionisContainerTypeError
+            If 'alias' is not of type `str` or `None`.
+        """
+
+        # Validate that 'lifetime' is an instance of Lifetime enum if provided
+        if self.lifetime and not isinstance(self.lifetime, Lifetime):
+            raise OrionisContainerTypeError(
+                f"The 'lifetime' attribute must be an instance of 'Lifetime', but received type '{type(self.lifetime).__name__}'."
+            )
+
+        # Validate that 'enforce_decoupling' is a boolean
+        if not isinstance(self.enforce_decoupling, bool):
+            raise OrionisContainerTypeError(
+                f"The 'enforce_decoupling' attribute must be of type 'bool', but received type '{type(self.enforce_decoupling).__name__}'."
+            )
+
+        # Validate that 'alias' is either a string or None
+        if self.alias and not isinstance(self.alias, str):
+            raise OrionisContainerTypeError(
+                f"The 'alias' attribute must be of type 'str' or 'None', but received type '{type(self.alias).__name__}'."
+            )

orionis-0.406.0/orionis/container/enums/lifetimes.py

@@ -0,0 +1,29 @@
+from enum import Enum, auto
+
+class Lifetime(Enum):
+    """
+    Represents the lifecycle types used for dependency injection.
+
+    This enumeration defines how and when instances of a dependency are created and shared.
+
+    Attributes
+    ----------
+    TRANSIENT : Lifetime
+        A new instance is created and provided every time the dependency is requested.
+    SINGLETON : Lifetime
+        A single shared instance is created and used throughout the entire application lifetime.
+    SCOPED : Lifetime
+        An instance is created and shared within a defined scope (such as per request or session).
+
+    Returns
+    -------
+    Lifetime
+        An enumeration member representing the selected lifecycle type.
+    """
+
+    # A new instance is provided every time the dependency is requested.
+    TRANSIENT = auto()
+    # A single shared instance is provided for the entire application lifetime.
+    SINGLETON = auto()
+    # An instance is provided per scope (e.g., per request or session).
+    SCOPED = auto()

{orionis-0.405.0 → orionis-0.406.0}/orionis/container/facades/facade.py

@@ -98,5 +98,4 @@ class Facade(metaclass=FacadeMeta):
             )
 
         # Resolve the service instance from the container
-        service_instance = cls._app.make(service_name, *args, **kwargs)
-        return service_instance
+        return cls._app.make(service_name, *args, **kwargs)

{orionis-0.405.0 → orionis-0.406.0}/orionis/container/providers/service_provider.py

@@ -31,7 +31,7 @@ class ServiceProvider(IServiceProvider):
         """
         self.app = app
 
-    def register(self) -> None:
+    async def register(self) -> None:
         """
         Register services into the application container.
 
@@ -46,7 +46,7 @@ class ServiceProvider(IServiceProvider):
         """
         raise NotImplementedError("This method should be overridden in the subclass")
 
-    def boot(self) -> None:
+    async def boot(self) -> None:
         """
         Perform any post-registration bootstrapping or initialization.