orionis 0.41.0__tar.gz → 0.43.0__tar.gz

{orionis-0.41.0/orionis.egg-info → orionis-0.43.0}/PKG-INFO

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

{orionis-0.41.0 → orionis-0.43.0}/orionis/framework.py

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

orionis-0.43.0/orionis/luminate/app.py

@@ -0,0 +1,99 @@
+import traceback
+from orionis.luminate.container.container import Container
+from orionis.luminate.cache.app.config import CacheConfig
+from orionis.luminate.bootstrap.config.register import Register
+from orionis.luminate.bootstrap.config.bootstrapper import Bootstrapper
+from orionis.luminate.patterns.singleton import SingletonMeta
+
+class Application(metaclass=SingletonMeta):
+    """
+    The main service container for the Orionis Framework, ensuring persistent dependency resolution.
+
+    This class acts as a singleton service container, similar to Laravel's Application class.
+    It maintains service bindings, ensures proper initialization, and prevents unnecessary re-instantiation.
+
+    Attributes
+    ----------
+    container : Container
+        The IoC container that holds all service bindings.
+    booted : bool
+        Indicates whether the application has been initialized.
+    error_info : tuple or None
+        Stores error information if an exception occurs during boot.
+
+    Methods
+    -------
+    boot()
+        Initializes the application and registers all necessary dependencies.
+    isBooted()
+        Checks if the application is currently running.
+    getError()
+        Retrieves stored error information, if any.
+    """
+
+    def __init__(self):
+        """Initializes the application with an empty dependency container."""
+        self.container = Container()
+        self.booted = False
+        self.error_info = None
+
+    def boot(self):
+        """
+        Boots the application and registers necessary dependencies.
+
+        This method ensures that all required services are bound to the container and instantiated.
+        If the application is already booted, it returns immediately.
+
+        Returns
+        -------
+        Application
+            The current instance of the application.
+
+        Raises
+        ------
+        Exception
+            If an error occurs during the boot process.
+        """
+        if self.booted:
+            return self
+
+        try:
+            # Register core services as singletons
+            self.container.singleton(CacheConfig)
+            self.container.singleton(Register)
+            self.container.singleton(Bootstrapper)
+
+            # Resolve the registered dependencies
+            self.container.make(Register)
+            self.container.make(Bootstrapper)
+
+            self.booted = True
+            return self
+
+        except Exception as e:
+            # Capture and store exception details
+            self.error_info = (e, traceback.format_exc())
+            raise
+
+    def isBooted(self):
+        """
+        Checks if the application has been successfully initialized.
+
+        Returns
+        -------
+        bool
+            True if the application has been booted, False otherwise.
+        """
+        return self.booted
+
+    def getError(self):
+        """
+        Retrieves the last stored error details.
+
+        Returns
+        -------
+        tuple or None
+            A tuple containing the exception instance and its formatted traceback if an error occurred;
+            otherwise, None.
+        """
+        return self.error_info

orionis-0.43.0/orionis/luminate/app_context.py

@@ -0,0 +1,58 @@
+from orionis.luminate.app import Application
+
+class AppContext:
+    """
+    Context manager for resolving dependencies within a valid Orionis application context.
+
+    This class ensures that Orionis is properly initialized before resolving dependencies,
+    similar to how Laravel’s `app()` helper works.
+
+    Methods
+    -------
+    __enter__()
+        Validates the application state and provides access to the service container.
+    __exit__(exc_type, exc_val, exc_tb)
+        Ensures exceptions propagate naturally.
+    """
+
+    def __enter__(self):
+        """
+        Validates that the Orionis application is booted before allowing access to the container.
+
+        Returns
+        -------
+        Container
+            The application’s IoC container instance.
+
+        Raises
+        ------
+        RuntimeError
+            If the application has not been properly initialized.
+        """
+        app = Application()
+        if not app.isBooted():
+            raise RuntimeError(
+                "Error: Not running within a valid Orionis Framework context. "
+                "Ensure that the Orionis application is correctly initialized."
+            )
+        return app.container
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Allows exceptions to propagate naturally.
+
+        Parameters
+        ----------
+        exc_type : type
+            The exception type, if an error occurred.
+        exc_val : Exception
+            The exception instance, if an error occurred.
+        exc_tb : traceback
+            The traceback object associated with the exception, if an error occurred.
+
+        Returns
+        -------
+        bool
+            Always returns False to ensure exceptions are not suppressed.
+        """
+        return False

{orionis-0.41.0 → orionis-0.43.0}/orionis/luminate/facades/config.py

@@ -1,10 +1,10 @@
 from orionis.luminate.container.container import Container
 from orionis.luminate.cache.app.config import CacheConfig
-from orionis.luminate.orionis import OrionisContext
+from orionis.luminate.app import OrionisContext
 
 class Config:
 
     @staticmethod
     def get():
         with OrionisContext() as ctx:
-            return ctx.make(CacheConfig).config
+            return ctx.container.make(CacheConfig).config

{orionis-0.41.0 → orionis-0.43.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.41.0 → orionis-0.43.0}/orionis.egg-info/SOURCES.txt

@@ -12,7 +12,8 @@ orionis.egg-info/entry_points.txt
 orionis.egg-info/requires.txt
 orionis.egg-info/top_level.txt
 orionis/luminate/__init__.py
-orionis/luminate/orionis.py
+orionis/luminate/app.py
+orionis/luminate/app_context.py
 orionis/luminate/bootstrap/__init__.py
 orionis/luminate/bootstrap/cli_exception.py
 orionis/luminate/bootstrap/commands/bootstrapper.py

orionis-0.41.0/orionis/luminate/orionis.py

@@ -1,142 +0,0 @@
-import traceback
-from orionis.luminate.container.container import Container
-from orionis.luminate.cache.app.config import CacheConfig
-from orionis.luminate.bootstrap.config.register import Register
-from orionis.luminate.bootstrap.config.bootstrapper import Bootstrapper
-from orionis.luminate.patterns.singleton import SingletonMeta
-
-class Orionis(metaclass=SingletonMeta):
-    """
-    Context manager for the Orionis application that handles startup and cleanup.
-
-    This class manages the lifecycle of an Orionis application instance.
-    It starts the application when entering the context and ensures that the
-    application is properly finished when exiting, capturing any exceptions that occur.
-
-    Attributes
-    ----------
-    is_started : bool
-        Flag indicating whether the application has been successfully started.
-    app : App
-        Instance of the Orionis application.
-    error_info : tuple or None
-        Tuple containing the exception instance and its formatted traceback if an error occurs;
-        otherwise, None.
-    """
-
-    def __init__(self):
-        """
-        Initialize the OrionisContext.
-
-        Sets up the application instance and initializes state variables.
-        """
-        self.container = Container()
-        self.is_started = False
-        self.error_info = None
-
-    def __enter__(self):
-        """
-        Enter the runtime context and start the application.
-
-        Attempts to start the Orionis application. If successful, sets the active flag
-        and returns the context instance. If an exception is raised during startup,
-        captures the exception and its traceback before re-raising it.
-
-        Returns
-        -------
-        OrionisContext
-            The current context instance with the application started.
-
-        Raises
-        ------
-        Exception
-            Re-raises any exception that occurs during the application startup.
-        """
-        try:
-
-            self.container.singleton(CacheConfig)
-            self.container.singleton(Register)
-            self.container.singleton(Bootstrapper)
-
-            self.container.make(Register)
-            self.container.make(Bootstrapper)
-
-            self.is_started = True
-            OrionisContext().is_started = True
-
-            return self
-
-        except Exception as e:
-
-            self.error_info = (e, traceback.format_exc())
-            raise
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """
-        Exit the runtime context and finish the application.
-
-        Calls the application's finish method to perform cleanup regardless of whether
-        an exception occurred. If an exception occurred, captures its information and
-        returns False to indicate that the exception should not be suppressed.
-
-        Parameters
-        ----------
-        exc_type : type
-            The type of the exception raised (if any).
-        exc_val : Exception
-            The exception instance raised (if any).
-        exc_tb : traceback
-            The traceback associated with the exception (if any).
-
-        Returns
-        -------
-        bool
-            Always returns False so that any exception is propagated.
-        """
-        try:
-            self.container = None
-        finally:
-            self.is_started = False
-
-        if exc_type:
-            self.error_info = (exc_val, traceback.format_exc())
-            return False
-
-    def isStarted(self):
-        """
-        Check if the application is currently active.
-
-        Returns
-        -------
-        bool
-            True if the application has been started and is active, False otherwise.
-        """
-        return self.is_started
-
-    def getError(self):
-        """
-        Retrieve the stored error information.
-
-        Returns
-        -------
-        tuple or None
-            A tuple containing the exception and its formatted traceback if an error occurred;
-            otherwise, None.
-        """
-        return self.error_info
-
-class OrionisContext(metaclass=SingletonMeta):
-
-    def __init__(self):
-        self.is_started = False
-
-    def __enter__(self):
-        if self.is_started:
-            return Orionis()
-        raise Exception(
-            "Error: Not running within a valid Orionis Framework context. "
-            "Please ensure that you are using the proper context manager."
-        )
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass