orionis 0.12.0__tar.gz → 0.14.0__tar.gz

{orionis-0.12.0/orionis.egg-info → orionis-0.14.0}/PKG-INFO

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

{orionis-0.12.0 → orionis-0.14.0}/orionis/framework.py

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

orionis-0.14.0/orionis/luminate/bootstrap/config/bootstrapper.py

@@ -0,0 +1,110 @@
+import ast
+import importlib
+import os
+from orionis.luminate.bootstrap.config.register import Register
+from orionis.luminate.contracts.bootstrap.bootstrapper_interface import IBootstrapper
+
+class Bootstrapper(IBootstrapper):
+    """
+    Manages the automatic loading and registration of configuration classes
+    from Python files located in a specified directory.
+
+    The `Bootstrapper` class scans directories for Python files and dynamically
+    imports them to find configuration classes. Once found, the classes are
+    registered using the provided `Register` instance.
+
+    Attributes
+    ----------
+    register : Register
+        An instance of the `Register` class used to register configuration classes.
+
+    Methods
+    -------
+    __init__(register: Register) -> None
+        Initializes the `Bootstrapper` with a `Register` instance.
+
+    findClasses(file_path: str) -> List[str]
+        Parses a Python file to extract and return all defined class names.
+
+    autoload(directory: str) -> None
+        Scans a directory for Python files, imports them, finds configuration classes,
+        and registers them using the `Register` instance.
+    """
+
+    def __init__(self, register: Register) -> None:
+        """
+        Initializes the `Bootstrapper` with a `Register` instance.
+
+        Parameters
+        ----------
+        register : Register
+            An instance of the `Register` class used to register configuration classes.
+        """
+        self.register = register
+
+    def findClasses(self, file_path: str):
+        """
+        Parses a Python file to extract and return all defined class names.
+
+        This method opens the file at the given path, parses it using the Abstract
+        Syntax Tree (AST) module to extract class definitions, and returns a
+        list of class names found within the file.
+
+        Parameters
+        ----------
+        file_path : str
+            The path to the Python file to parse.
+
+        Returns
+        -------
+        List[str]
+            A list of class names defined in the provided Python file.
+        """
+        classes = []
+        with open(file_path, "r", encoding="utf-8") as file:
+            tree = ast.parse(file.read())
+
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef):
+                    classes.append(node.name)
+
+        return classes
+
+    def autoload(self, directory: str) -> None:
+        """
+        Automatically registers configuration classes found in a given directory.
+
+        This method walks through the specified directory, imports all Python files,
+        and scans for class definitions. If a class is found, it is registered using
+        the `Register` instance. Only classes defined in Python files (excluding
+        `__init__.py`) are considered.
+
+        Parameters
+        ----------
+        directory : str
+            The directory to scan for Python configuration files.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the provided directory does not exist.
+        """
+        if not os.path.isdir(directory):
+            raise FileNotFoundError(f"Directory '{directory}' not found.")
+
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if file.endswith(".py") and file != "__init__.py":
+                    file_path = os.path.join(root, file)
+                    # Get the class names defined in the file
+                    classes = self.findClasses(file_path)
+
+                    if classes:
+                        for class_name in classes:
+                            # Construct the module path and import the module
+                            module_path = root.replace(os.getcwd(), "").replace(os.sep, ".") + "." + file[:-3]
+                            module = importlib.import_module(module_path)
+                            class_obj = getattr(module, class_name)
+
+                            # Register the class in the container using the Register instance
+                            self.register.config(class_obj)

{orionis-0.12.0/orionis/luminate/bootstrap → orionis-0.14.0/orionis/luminate/bootstrap/config}/parser.py

@@ -41,8 +41,12 @@ class Parser(IParser):
             If the `config` attribute cannot be converted to a dictionary.
         """
         try:
-            # Convert dataclass using asdict()
-            return asdict(instance.config)
+            # Check if instance is a dictionary
+            if isinstance(instance.config, dict):
+                return instance
+            # Check if instance is a dataclass
+            elif hasattr(instance.config, '__dataclass_fields__'):
+                return asdict(instance.config)
         except AttributeError as e:
             raise AttributeError("The provided instance does not have a 'config' attribute.") from e
         except TypeError as e:

{orionis-0.12.0/orionis/luminate/bootstrap → orionis-0.14.0/orionis/luminate/bootstrap/config}/register.py

@@ -1,10 +1,11 @@
-from orionis.luminate.bootstrap.parser import Parser
+from orionis.luminate.bootstrap.config.parser import Parser
 from orionis.luminate.config.sections import SECTIONS
-from orionis.luminate.tools.reflection import Reflection
-from orionis.luminate.cache.app.config import CacheConfig
+from orionis.luminate.container.container import Container
+from orionis.luminate.contracts.bootstrap.register_interface import IRegister
 from orionis.luminate.contracts.config.config_interface import IConfig
+from orionis.luminate.tools.reflection import Reflection
 
-class Register:
+class Register(IRegister):
     """
     Handles the registration of configuration classes within the application.
 
@@ -22,7 +23,7 @@ class Register:
         Registers a configuration class and ensures it meets the necessary criteria.
     """
 
-    def __init__(self, cache: CacheConfig = None):
+    def __init__(self, container: Container) -> None:
         """
         Initializes the Register instance with a cache configuration.
 
@@ -31,7 +32,7 @@ class Register:
         cache : CacheConfig, optional
             The cache configuration instance to be used (default is a new instance of `CacheConfig`).
         """
-        self.cache_config = cache or CacheConfig()
+        self.container = container
 
     def config(self, config_class: type) -> type:
         """
@@ -78,18 +79,8 @@ class Register:
         if not issubclass(config_class, IConfig):
             raise TypeError(f"Class {config_class.__name__} must inherit from 'IConfig'.")
 
-        # Check if section is already registered
-        if section in self.cache_config.config:
-            raise ValueError(f"Configuration section '{section}' is already registered.")
-
         # Register configuration
-        self.cache_config.register(
+        self.container.config(
             section=section,
             data=Parser.toDict(config_class)
-        )
-
-        # Return the original class
-        return config_class
-
-# Create a global Register instance
-register = Register()
+        )

{orionis-0.12.0 → orionis-0.14.0}/orionis/luminate/container/container.py

@@ -1,6 +1,7 @@
 import inspect
 from typing import Any, Callable
 from orionis.luminate.container.types import Types
+from orionis.luminate.tools.dot_dict import DotDict
 from orionis.luminate.contracts.container.container_interface import IContainer
 from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerValueError
 
@@ -12,6 +13,8 @@ class Container(IContainer):
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
+            cls._config = {}
+            
             cls._instance._bindings = {}
             cls._instance._transients = {}
             cls._instance._singletons = {}
@@ -24,6 +27,28 @@ class Container(IContainer):
             cls._instance._primitive_types_validator = Types()
         return cls._instance
 
+    def config(self, section: str, data: dict):
+        """
+        Registers a configuration section in the container.
+
+        Args:
+            section (str): _description_
+            data (dict): _description_
+        """
+
+        # Validate that data is a dictionary
+        if not isinstance(data, dict):
+            raise OrionisContainerValueError("The 'data' parameter must be a dictionary.")
+
+        # Validate that the section is a string
+        if not isinstance(section, str):
+            raise OrionisContainerValueError("The 'section' parameter must be a string.")
+
+        if section not in self._config:
+            self._config[section] = data
+        else:
+            self._config[section].update(data)
+
     def bind(self, abstract: str, concrete: Callable[..., Any]) -> None:
         """Registers a service with a specific implementation.
 

orionis-0.14.0/orionis/luminate/contracts/bootstrap/bootstrapper_interface.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+from ast import List
+
+class IBootstrapper(ABC):
+    """
+    Interface for managing the automatic loading and registration of configuration
+    classes from Python files located in a specified directory.
+
+    The `IBootstrapper` interface defines methods for scanning directories for
+    Python files and dynamically importing them to find configuration classes.
+    Implementations of this interface should provide the logic for registering
+    the found classes using a `Register` instance.
+
+    Methods
+    -------
+    findClasses(file_path: str) -> List[str]
+        Parses a Python file to extract and return all defined class names.
+
+    autoload(directory: str) -> None
+        Scans a directory for Python files, imports them, finds configuration classes,
+        and registers them using the `Register` instance.
+    """
+
+    @abstractmethod
+    def findClasses(self, file_path: str) -> List[str]:
+        """
+        Parses a Python file to extract and return all defined class names.
+
+        This method opens the file at the given path, parses it using the Abstract
+        Syntax Tree (AST) module to extract class definitions, and returns a
+        list of class names found within the file.
+
+        Parameters
+        ----------
+        file_path : str
+            The path to the Python file to parse.
+
+        Returns
+        -------
+        List[str]
+            A list of class names defined in the provided Python file.
+        """
+        pass
+
+    @abstractmethod
+    def autoload(self, directory: str) -> None:
+        """
+        Automatically registers configuration classes found in a given directory.
+
+        This method walks through the specified directory, imports all Python files,
+        and scans for class definitions. If a class is found, it is registered using
+        the `Register` instance. Only classes defined in Python files (excluding
+        `__init__.py`) are considered.
+
+        Parameters
+        ----------
+        directory : str
+            The directory to scan for Python configuration files.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the provided directory does not exist.
+        """
+        pass

orionis-0.14.0/orionis/luminate/contracts/bootstrap/register_interface.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+
+class IRegister(ABC):
+    """
+    Handles the registration of configuration classes within the application.
+
+    This class ensures that only valid configuration classes are registered
+    while enforcing structure and type safety.
+
+    Attributes
+    ----------
+    cache_config : CacheConfig
+        An instance of `CacheConfig` used to store registered configurations.
+
+    Methods
+    -------
+    config(config_class: type) -> type
+        Registers a configuration class and ensures it meets the necessary criteria.
+    """
+
+    @abstractmethod
+    def config(self, config_class: type) -> type:
+        """
+        Registers a configuration class and ensures it meets the required structure.
+
+        This method performs multiple validation steps, including checking if the input
+        is a class, verifying the existence of a `config` attribute, and confirming
+        inheritance from `IConfig`.
+
+        Parameters
+        ----------
+        config_class : type
+            The class to be registered as a configuration.
+
+        Returns
+        -------
+        type
+            The same class passed as an argument, if registration is successful.
+
+        Raises
+        ------
+        TypeError
+            If `config_class` is not a class or does not inherit from `IConfig`.
+        ValueError
+            If `config_class` does not have a `config` attribute or is already registered.
+        """
+        pass

{orionis-0.12.0 → orionis-0.14.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.12.0 → orionis-0.14.0}/orionis.egg-info/SOURCES.txt

@@ -14,8 +14,10 @@ orionis.egg-info/top_level.txt
 orionis/luminate/__init__.py
 orionis/luminate/app.py
 orionis/luminate/bootstrap/__init__.py
-orionis/luminate/bootstrap/parser.py
-orionis/luminate/bootstrap/register.py
+orionis/luminate/bootstrap/config/__init__.py
+orionis/luminate/bootstrap/config/bootstrapper.py
+orionis/luminate/bootstrap/config/parser.py
+orionis/luminate/bootstrap/config/register.py
 orionis/luminate/cache/__init__.py
 orionis/luminate/cache/app/__init__.py
 orionis/luminate/cache/app/config.py
@@ -66,7 +68,9 @@ orionis/luminate/container/container.py
 orionis/luminate/container/exception.py
 orionis/luminate/container/types.py
 orionis/luminate/contracts/__init__.py
+orionis/luminate/contracts/bootstrap/bootstrapper_interface.py
 orionis/luminate/contracts/bootstrap/parser_interface.py
+orionis/luminate/contracts/bootstrap/register_interface.py
 orionis/luminate/contracts/cache/__init__.py
 orionis/luminate/contracts/cache/cache_commands_interface.py
 orionis/luminate/contracts/config/__init__.py