orionis 0.43.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

orionis/luminate/facades/environment/environment_facade.py

@@ -0,0 +1,68 @@
+from orionis.contracts.facades.environment.i_environment_facade import IEnv
+from orionis.luminate.app_context import AppContext
+
+def env(key: str, default=None) -> str:
+    """
+    Retrieves the value of an environment variable.
+
+    This function provides a convenient way to access environment variables
+    stored in the application context. If the variable does not exist, it
+    returns the specified default value.
+
+    Parameters
+    ----------
+    key : str
+        The name of the environment variable to retrieve.
+    default : Any, optional
+        The default value to return if the environment variable does not exist.
+        Defaults to None.
+
+    Returns
+    -------
+    str
+        The value of the environment variable, or the default value if the variable
+        does not exist.
+    """
+    with AppContext() as app:
+        env : dict = app._environment_vars
+        return env.get(key, default)
+
+class Env(IEnv):
+    """
+    A facade class for accessing environment variables.
+
+    This class provides a static method to retrieve environment variables
+    stored in the application context. It implements the `IEnv` interface.
+
+    Methods
+    -------
+    get(key: str, default=None) -> str
+        Retrieves the value of an environment variable.
+    """
+
+    @staticmethod
+    def get(key: str, default=None) -> str:
+        """
+        Retrieves the value of an environment variable.
+
+        This method provides a convenient way to access environment variables
+        stored in the application context. If the variable does not exist, it
+        returns the specified default value.
+
+        Parameters
+        ----------
+        key : str
+            The name of the environment variable to retrieve.
+        default : Any, optional
+            The default value to return if the environment variable does not exist.
+            Defaults to None.
+
+        Returns
+        -------
+        str
+            The value of the environment variable, or the default value if the variable
+            does not exist.
+        """
+        with AppContext() as app:
+            env : dict = app._environment_vars
+            return env.get(key, default)

orionis/luminate/facades/{paths.py → files/path_facade.py}

@@ -1,25 +1,60 @@
 import os
-from orionis.luminate.files.paths import SkeletonPath
-from orionis.luminate.contracts.facades.paths_interface import IPath
+from orionis.contracts.facades.files.i_path_facade import IPath
+from orionis.luminate.app_context import AppContext
+from orionis.luminate.services.files.path_service import PathService
 
 class Path(IPath):
+    """
+    A facade class for resolving absolute paths to various application directories.
+
+    This class provides static methods to resolve paths to common directories such as
+    'app', 'config', 'database', 'resources', 'routes', 'storage', and 'tests'.
+    It uses the `PathService` to resolve and validate paths.
+
+    Methods
+    -------
+    _resolve_directory(directory: str, file: str = None) -> SkeletonPath
+        Resolves the absolute path for a given directory and optional file.
+    app(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'app' directory.
+    config(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'config' directory.
+    database(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'database' directory.
+    resource(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'resource' directory.
+    routes(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'routes' directory.
+    storage(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'storage' directory.
+    tests(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'tests' directory.
+    """
 
     @staticmethod
     def _resolve_directory(directory: str, file: str = None):
         """
-        Internal helper function to resolve an absolute path for a given directory.
+        Resolves the absolute path for a given directory and optional file.
+
+        This method constructs a path by joining the directory and file, normalizes it,
+        and resolves it using the `PathService`.
 
         Parameters
         ----------
         directory : str
             The base directory to resolve the path from.
         file : str, optional
-            The relative file path inside the directory (default is an empty string).
+            The relative file path inside the directory (default is None).
 
         Returns
         -------
         SkeletonPath
             The resolved absolute path wrapped in a SkeletonPath object.
+
+        Raises
+        ------
+        ValueError
+            If the resolved path is invalid or cannot be resolved.
         """
         # Default to an empty string if None
         file = file or ""
@@ -30,7 +65,10 @@ class Path(IPath):
         # Normalize path (removes redundant slashes)
         route = os.path.normpath(route)
 
-        return SkeletonPath(route).resolve()
+        # Obtain the path service from the container
+        with AppContext() as app:
+            path_service : PathService = app.container.make(PathService)
+            return path_service.resolve(route)
 
     @staticmethod
     def app(file: str = None):
@@ -171,6 +209,7 @@ def app_path(file: str = None):
     """
     return Path._resolve_directory("app", file)
 
+
 def config_path(file: str = None):
     """
     Returns the absolute path for a file inside the 'config' directory.
@@ -187,6 +226,7 @@ def config_path(file: str = None):
     """
     return Path._resolve_directory("config", file)
 
+
 def database_path(file: str = None):
     """
     Returns the absolute path for a file inside the 'database' directory.
@@ -203,6 +243,7 @@ def database_path(file: str = None):
     """
     return Path._resolve_directory("database", file)
 
+
 def resource_path(file: str = None):
     """
     Returns the absolute path for a file inside the 'resource' directory.
@@ -219,6 +260,7 @@ def resource_path(file: str = None):
     """
     return Path._resolve_directory("resource", file)
 
+
 def routes_path(file: str = None):
     """
     Returns the absolute path for a file inside the 'routes' directory.
@@ -235,6 +277,7 @@ def routes_path(file: str = None):
     """
     return Path._resolve_directory("routes", file)
 
+
 def storage_path(file: str = None):
     """
     Returns the absolute path for a file inside the 'storage' directory.
@@ -251,6 +294,7 @@ def storage_path(file: str = None):
     """
     return Path._resolve_directory("storage", file)
 
+
 def tests_path(file: str = None):
     """
     Returns the absolute path for a file inside the 'tests' directory.
@@ -265,4 +309,4 @@ def tests_path(file: str = None):
     SkeletonPath
         The resolved path wrapped in a SkeletonPath object.
     """
-    return Path._resolve_directory("tests", file)
+    return Path._resolve_directory("tests", file)

orionis/luminate/facades/log/log_facade.py

@@ -0,0 +1,95 @@
+from orionis.contracts.facades.log.i_log_facade import ILog
+from orionis.luminate.app_context import AppContext
+from orionis.luminate.services.log.log_service import LogguerService
+
+class Log(ILog):
+    """
+    A facade class for logging messages with different severity levels.
+
+    This class provides static methods to log messages using the `LogguerService`.
+    It simplifies the process of logging by abstracting the service resolution
+    and providing a clean interface for logging.
+
+    Methods
+    -------
+    info(message: str) -> None
+        Logs an informational message.
+    error(message: str) -> None
+        Logs an error message.
+    success(message: str) -> None
+        Logs a success message.
+    warning(message: str) -> None
+        Logs a warning message.
+    debug(message: str) -> None
+        Logs a debug message.
+    """
+
+    @staticmethod
+    def info(message: str) -> None:
+        """
+        Logs an informational message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        with AppContext() as app:
+            log_service: LogguerService = app.container.make(LogguerService)
+            log_service.info(message)
+
+    @staticmethod
+    def error(message: str) -> None:
+        """
+        Logs an error message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        with AppContext() as app:
+            log_service: LogguerService = app.container.make(LogguerService)
+            log_service.error(message)
+
+    @staticmethod
+    def success(message: str) -> None:
+        """
+        Logs a success message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        with AppContext() as app:
+            log_service: LogguerService = app.container.make(LogguerService)
+            log_service.success(message)
+
+    @staticmethod
+    def warning(message: str) -> None:
+        """
+        Logs a warning message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        with AppContext() as app:
+            log_service: LogguerService = app.container.make(LogguerService)
+            log_service.warning(message)
+
+    @staticmethod
+    def debug(message: str) -> None:
+        """
+        Logs a debug message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        with AppContext() as app:
+            log_service: LogguerService = app.container.make(LogguerService)
+            log_service.debug(message)

orionis/luminate/facades/{tests.py → tests/tests_facade.py}

@@ -1,6 +1,6 @@
 import os
+from orionis.contracts.facades.tests.i_tests_facade import IUnitTests
 from orionis.luminate.test.unit_test import UnitTest
-from orionis.luminate.contracts.facades.tests_interface import IUnitTests
 
 class UnitTests(IUnitTests):
     """

orionis/luminate/pipelines/cli_pipeline.py

@@ -1,116 +1,122 @@
-import argparse
-from typing import Dict, Any, Optional
-from orionis.luminate.console.parser import Parser
-from orionis.luminate.console.cache import CLICache
-from orionis.luminate.console.base.command import BaseCommand
-from orionis.luminate.contracts.pipelines.cli_pipeline_interface import ICLIPipeline
-
-class CLIPipeline(ICLIPipeline):
-    """
-    Handles the retrieval, parsing, and execution of CLI commands within the Orionis framework.
-
-    This class is responsible for:
-    - Retrieving command metadata from cache.
-    - Parsing command-line arguments dynamically.
-    - Executing the corresponding command with parsed arguments.
-
-    Attributes
-    ----------
-    _command : dict
-        Stores the command's metadata, including its instance and expected arguments.
-    _parsed_arguments : argparse.Namespace
-        Holds parsed arguments after processing user input.
-    """
-
-    def __init__(self):
-        """
-        Initializes the CLIPipeline instance with an empty command cache
-        and a default argument namespace.
-        """
-        self._command: Dict[str, Any] = {}
-        self._parsed_arguments: argparse.Namespace = argparse.Namespace()
-
-    def getCommand(self, signature: str) -> "CLIPipeline":
-        """
-        Retrieves a command from the cache based on its signature.
-
-        Parameters
-        ----------
-        signature : str
-            The unique identifier of the command.
-
-        Returns
-        -------
-        CLIPipeline
-            The current instance of CLIPipeline for method chaining.
-
-        Raises
-        ------
-        ValueError
-            If the command signature is not found in the cache.
-        """
-        try:
-            cache = CLICache().getCommands()
-            self._command = cache.get(signature)
-            return self
-        except KeyError as e:
-            raise ValueError(e)
-
-    def parseArguments(self, vars: Optional[Dict[str, Any]] = None, *args, **kwargs) -> "CLIPipeline":
-        """
-        Parses command-line arguments using the Orionis argument parser.
-
-        Parameters
-        ----------
-        vars : dict, optional
-            A dictionary of predefined variables to be included in parsing.
-        *args
-            Positional arguments for the parser.
-        **kwargs
-            Keyword arguments for the parser.
-
-        Returns
-        -------
-        CLIPipeline
-            The current instance of CLIPipeline for method chaining.
-
-        Raises
-        ------
-        ValueError
-            If an error occurs during argument parsing.
-        """
-        try:
-            arguments = self._command.get("arguments")
-            if arguments:
-                arg_parser = Parser(vars=vars or {}, args=args, kwargs=kwargs)
-                arg_parser.setArguments(arguments=arguments)
-                arg_parser.recognize()
-                self._parsed_arguments = arg_parser.get()
-
-            return self
-
-        except Exception as e:
-            raise ValueError(f"Error parsing arguments: {e}")
-
-    def execute(self) -> Any:
-        """
-        Executes the retrieved command using parsed arguments.
-
-        This method:
-        - Instantiates the command class.
-        - Calls the `handle()` method, passing the parsed arguments.
-
-        Returns
-        -------
-        Any
-            The output of the command execution.
-
-        Raises
-        ------
-        ValueError
-            If the command instance is invalid.
-        """
-        command_class = self._command.get("instance")
-        command_instance: BaseCommand = command_class()
-        command_instance.setArgs(self._parsed_arguments)
-        return command_instance.handle(**vars(self._parsed_arguments))
+# import argparse
+# from typing import Dict, Any, Optional
+# from orionis.luminate.app_context import AppContext
+# from orionis.luminate.console.parser import Parser
+# from orionis.luminate.console.cache import CLICache
+# from orionis.luminate.console.base.command import BaseCommand
+# from orionis.luminate.contracts.pipelines.cli_pipeline_interface import ICLIPipeline
+
+class CLIPipeline:
+    pass
+    # """
+    # Handles the retrieval, parsing, and execution of CLI commands within the Orionis framework.
+
+    # This class is responsible for:
+    # - Retrieving command metadata from cache.
+    # - Parsing command-line arguments dynamically.
+    # - Executing the corresponding command with parsed arguments.
+
+    # Attributes
+    # ----------
+    # _command : dict
+    #     Stores the command's metadata, including its instance and expected arguments.
+    # _parsed_arguments : argparse.Namespace
+    #     Holds parsed arguments after processing user input.
+    # """
+
+    # def __init__(self):
+    #     """
+    #     Initializes the CLIPipeline instance with an empty command cache
+    #     and a default argument namespace.
+    #     """
+    #     self._command: Dict[str, Any] = {}
+    #     self._parsed_arguments: argparse.Namespace = argparse.Namespace()
+
+    # def getCommand(self, signature: str) -> "CLIPipeline":
+    #     """
+    #     Retrieves a command from the cache based on its signature.
+
+    #     Parameters
+    #     ----------
+    #     signature : str
+    #         The unique identifier of the command.
+
+    #     Returns
+    #     -------
+    #     CLIPipeline
+    #         The current instance of CLIPipeline for method chaining.
+
+    #     Raises
+    #     ------
+    #     ValueError
+    #         If the command signature is not found in the cache.
+    #     """
+    #     with AppContext() as app:
+    #         config_service : BaseCommand = app.container.run_command("config")
+    #         config_service.
+            
+    #     try:
+    #         cache = CLICache().getCommands()
+    #         self._command = cache.get(signature)
+    #         return self
+    #     except KeyError as e:
+    #         raise ValueError(e)
+
+    # def parseArguments(self, vars: Optional[Dict[str, Any]] = None, *args, **kwargs) -> "CLIPipeline":
+    #     """
+    #     Parses command-line arguments using the Orionis argument parser.
+
+    #     Parameters
+    #     ----------
+    #     vars : dict, optional
+    #         A dictionary of predefined variables to be included in parsing.
+    #     *args
+    #         Positional arguments for the parser.
+    #     **kwargs
+    #         Keyword arguments for the parser.
+
+    #     Returns
+    #     -------
+    #     CLIPipeline
+    #         The current instance of CLIPipeline for method chaining.
+
+    #     Raises
+    #     ------
+    #     ValueError
+    #         If an error occurs during argument parsing.
+    #     """
+    #     try:
+    #         arguments = self._command.get("arguments")
+    #         if arguments:
+    #             arg_parser = Parser(vars=vars or {}, args=args, kwargs=kwargs)
+    #             arg_parser.setArguments(arguments=arguments)
+    #             arg_parser.recognize()
+    #             self._parsed_arguments = arg_parser.get()
+
+    #         return self
+
+    #     except Exception as e:
+    #         raise ValueError(f"Error parsing arguments: {e}")
+
+    # def execute(self) -> Any:
+    #     """
+    #     Executes the retrieved command using parsed arguments.
+
+    #     This method:
+    #     - Instantiates the command class.
+    #     - Calls the `handle()` method, passing the parsed arguments.
+
+    #     Returns
+    #     -------
+    #     Any
+    #         The output of the command execution.
+
+    #     Raises
+    #     ------
+    #     ValueError
+    #         If the command instance is invalid.
+    #     """
+    #     command_class = self._command.get("instance")
+    #     command_instance: BaseCommand = command_class()
+    #     command_instance.setArgs(self._parsed_arguments)
+    #     return command_instance.handle(**vars(self._parsed_arguments))

orionis/luminate/providers/config/config_service_provider.py

@@ -0,0 +1,26 @@
+from orionis.contracts.providers.i_service_provider import IServiceProvider
+from orionis.luminate.container.container import Container
+from orionis.luminate.services.config.config_service import ConfigService
+
+class ConfigServiceProvider(IServiceProvider):
+
+    def register(self, container: Container) -> None:
+        """
+        Registers services or bindings into the given container.
+
+        Args:
+            container (Container): The container to register services or bindings into.
+        """
+        self.key_sp = container.scoped(ConfigService)
+
+    def boot(self, container: Container) -> None:
+        """
+        Boot the service provider.
+
+        This method is intended to be overridden by subclasses to perform
+        any necessary bootstrapping or initialization tasks.
+
+        Args:
+            container (Container): The service container instance.
+        """
+        container.make(self.key_sp)

orionis/luminate/providers/files/path_service_provider.py

@@ -0,0 +1,26 @@
+from orionis.contracts.providers.i_service_provider import IServiceProvider
+from orionis.luminate.container.container import Container
+from orionis.luminate.services.files.path_service import PathService
+
+class PathServiceProvider(IServiceProvider):
+
+    def register(self, container: Container) -> None:
+        """
+        Registers services or bindings into the given container.
+
+        Args:
+            container (Container): The container to register services or bindings into.
+        """
+        self.key_sp = container.singleton(PathService)
+
+    def boot(self, container: Container) -> None:
+        """
+        Boot the service provider.
+
+        This method is intended to be overridden by subclasses to perform
+        any necessary bootstrapping or initialization tasks.
+
+        Args:
+            container (Container): The service container instance.
+        """
+        container.make(self.key_sp)

orionis/luminate/providers/log/log_service_provider.py

@@ -0,0 +1,26 @@
+from orionis.contracts.providers.i_service_provider import IServiceProvider
+from orionis.luminate.container.container import Container
+from orionis.luminate.services.log.log_service import LogguerService
+
+class LogServiceProvider(IServiceProvider):
+
+    def register(self, container: Container) -> None:
+        """
+        Registers services or bindings into the given container.
+
+        Args:
+            container (Container): The container to register services or bindings into.
+        """
+        self.key_sp = container.singleton(LogguerService)
+
+    def boot(self, container: Container) -> None:
+        """
+        Boot the service provider.
+
+        This method is intended to be overridden by subclasses to perform
+        any necessary bootstrapping or initialization tasks.
+
+        Args:
+            container (Container): The service container instance.
+        """
+        container.make(self.key_sp)