orionis 0.370.0__tar.gz → 0.372.0__tar.gz

{orionis-0.370.0/orionis.egg-info → orionis-0.372.0}/PKG-INFO

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

orionis-0.372.0/orionis/__init__.py

@@ -0,0 +1,7 @@
+from orionis.foundation.application import Application as Orionis
+from orionis.foundation.contracts.application import IApplication as IOrionis
+
+__all__ = [
+    "Orionis",
+    "IOrionis"
+]

{orionis-0.370.0 → orionis-0.372.0}/orionis/container/container.py

@@ -20,83 +20,82 @@ from orionis.services.introspection.callables.reflection import ReflectionCallab
 
 class Container(IContainer):
 
-    # Singleton instance of the container.
-    # This is a class variable that holds the single instance of the Container class.
-    _instance = None
-
-    # Lock for thread-safe singleton instantiation.
-    # This lock ensures that only one thread can create the instance at a time,
-    # preventing
-    _lock = threading.Lock()
-
-    # Class variable to track if the container has been initialized.
-    # This is used to ensure that the initialization logic runs only once,
-    # regardless of how many times the class is instantiated.
-    _initialized = False
-
-    def __new__(
-        cls
-    ) -> 'Container':
+    # Dictionary to hold singleton instances for each class
+    # This allows proper inheritance of the singleton pattern
+    _instances = {}
+
+    # Lock for thread-safe singleton instantiation and access
+    # This lock ensures that only one thread can create or access instances at a time
+    _lock = threading.RLock()  # RLock allows reentrant locking
+
+    def __new__(cls) -> 'Container':
         """
-        Creates and returns a singleton instance of the class.
+        Creates and returns a singleton instance for each specific class.
 
-        This method implements the singleton pattern, ensuring that only one instance
-        of the class exists. If an instance does not exist, it acquires a lock to
-        ensure thread safety and creates the instance. Subsequent calls return the
-        existing instance.
+        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
         -------
         Container
-            The singleton instance of the class.
+            The singleton instance of the specific class.
+
+        Notes
+        -----
+        This implementation is completely thread-safe and guarantees that:
+        - Only one instance per class exists across all threads
+        - Memory visibility is properly handled
+        - No race conditions can occur
+        - Inheritance is properly supported
         """
 
-        # Check if the class has an existing instance
-        if cls._instance is None:
+        # First check without lock for performance (fast path)
+        if cls in cls._instances:
+            return cls._instances[cls]
 
-            # Acquire the lock to ensure thread safety during instance creation
-            with cls._lock:
+        # Acquire the lock for the slow path (instance creation)
+        with cls._lock:
 
-                # If the instance is still None, create a new instance
-                if cls._instance is None:
+            # Double-check if the instance was created by another thread
+            # while we were waiting for the lock
+            if cls in cls._instances:
+                return cls._instances[cls]
 
-                    # Call the superclass's __new__ method to create a new instance
-                    cls._instance = super(Container, cls).__new__(cls)
+            # Create a new instance for this specific class
+            instance = super(Container, cls).__new__(cls)
 
-        # Return the existing instance of the class
-        return cls._instance
+            # Store the instance in the class-specific dictionary
+            # This write is protected by the lock, ensuring memory visibility
+            cls._instances[cls] = instance
 
-    def __init__(
-        self
-    ) -> None:
+            return instance
+
+    def __init__(self) -> None:
         """
         Initializes a new instance of the container.
 
         This constructor sets up the internal dictionaries for bindings and aliases,
-        ensuring that these are only initialized once per class. The initialization
-        is guarded by the `_initialized` class attribute to prevent redundant setup.
-        The container also registers itself as a service to allow for injection.
+        ensuring that these are only initialized once per instance. The initialization
+        is guarded by checking if the instance already has the required attributes.
 
         Notes
         -----
         - The `__bindings` dictionary is used to store service bindings.
         - The `__aliasses` dictionary is used to store service aliases.
-        - Initialization occurs only once per class, regardless of the number of instances.
+        - Initialization occurs only once per instance, regardless of how many times __init__ is called.
         - The container registers itself under the IContainer interface to allow for dependency injection.
         """
 
-        # Check if the class has been initialized
-        if not self.__class__._initialized:
+        # Check if the instance has already been initialized
+        if not hasattr(self, '_Container__initialized'):
 
             # Initialize the container's internal state
             self.__bindings = {}
             self.__aliasses = {}
 
-            # Set the initialized flag to True to prevent re-initialization
-            self.__class__._initialized = True
-
-            # Register the container itself as a service
-            self.instance(IContainer, self)
+            # Mark this instance as initialized
+            self.__initialized = True
 
     def transient(
         self,

{orionis-0.370.0 → orionis-0.372.0}/orionis/container/contracts/container.py

@@ -245,4 +245,27 @@ class IContainer(ABC):
         alias : str, optional
             The alias of the service to be removed.
         """
+        pass
+
+    @abstractmethod
+    def createContext(self):
+        """
+        Creates a new context for managing scoped services.
+
+        This method returns a context manager that can be used with a 'with' statement
+        to control the lifecycle of scoped services.
+
+        Returns
+        -------
+        ScopeManager
+            A context manager for scoped services.
+
+        Usage
+        -------
+        with container.createContext():
+            # Scoped services created here will be disposed when exiting this block
+            service = container.make(IScopedService)
+            ...
+        # Scoped services are automatically disposed here
+        """
         pass

{orionis-0.370.0 → orionis-0.372.0}/orionis/foundation/application.py

@@ -1,8 +1,9 @@
 from typing import Type, List
 from orionis.container.container import Container
 from orionis.container.contracts.service_provider import IServiceProvider
+from orionis.foundation.contracts.application import IApplication
 
-class App(Container):
+class Application(Container, IApplication):
     """
     Application container that manages service providers.
 
@@ -33,10 +34,60 @@ class App(Container):
         Initialize a new App instance.
 
         Sets up the container and initializes the provider tracking system.
+        This method ensures that initialization only happens once per instance,
+        even in a singleton context.
         """
+
+        # Call parent constructor first
         super().__init__()
-        self.__providers: List[IServiceProvider] = []
-        self.__booted: bool = False
+
+        # Check if this specific instance has already been initialized
+        if not hasattr(self, '_Application__initialized'):
+
+            # Initialize provider-specific attributes
+            self.__providers: List[IServiceProvider] = []
+            self.__booted: bool = False
+
+            # Mark this instance as initialized
+            self.__initialized = True
+
+            # Bootstrap core services
+            self.__bootFramework()
+
+    def __bootFramework(self) -> None:
+        """
+        Bootstrap the application by loading internal framework providers.
+
+        This method should be called once to ensure that core services
+        required by the framework are registered before user-defined
+        providers are loaded.
+        """
+        if not self.__booted:
+            self.__loadFrameworkProviders()
+
+    def __loadFrameworkProviders(self) -> None:
+        """
+        Load internal framework service providers.
+
+        This method should register core services required by the framework
+        before user-defined providers are loaded.
+        """
+        from orionis.foundation.providers.console_provider import ConsoleProvider
+        from orionis.foundation.providers.dumper_provider import DumperProvider
+        from orionis.foundation.providers.path_resolver_provider import PathResolverProvider
+        from orionis.foundation.providers.progress_bar_provider import ProgressBarProvider
+        from orionis.foundation.providers.workers_provider import WorkersProvider
+
+        core_providers = [
+            ConsoleProvider,
+            DumperProvider,
+            PathResolverProvider,
+            ProgressBarProvider,
+            WorkersProvider
+        ]
+
+        for provider_cls in core_providers:
+            self.__registerProvider(provider_cls)
 
     def __registerProvider(
         self,
@@ -90,32 +141,7 @@ class App(Container):
 
         self.__booted = True
 
-    def __loadFrameworkProviders(self) -> None:
-        """
-        Load internal framework service providers.
-
-        This method should register core services required by the framework
-        before user-defined providers are loaded.
-        """
-        from orionis.foundation.providers.console_provider import ConsoleProvider
-        from orionis.foundation.providers.dumper_provider import DumperProvider
-        from orionis.foundation.providers.path_resolver_provider import PathResolverProvider
-        from orionis.foundation.providers.progress_bar_provider import ProgressBarProvider
-        from orionis.foundation.providers.workers_provider import WorkersProvider
-
-        core_providers = [
-            ConsoleProvider,
-            DumperProvider,
-            PathResolverProvider,
-            ProgressBarProvider,
-            WorkersProvider
-        ]
-
-        for provider_cls in core_providers:
-            self.__registerProvider(provider_cls)
-
-
-    def load(self, providers: List[Type[IServiceProvider]]) -> None:
+    def load(self, providers: List[Type[IServiceProvider]] = []) -> None:
         """
         Load and boot a list of service providers.
 
@@ -131,9 +157,6 @@ class App(Container):
         None
         """
 
-        # Load internal framework providers first
-        self.__loadFrameworkProviders()
-
         # Register and boot each provided service provider
         for provider_cls in providers:
             self.__registerProvider(provider_cls)

orionis-0.372.0/orionis/foundation/contracts/application.py

@@ -0,0 +1,58 @@
+from abc import abstractmethod
+from typing import List, Type
+from orionis.container.contracts.service_provider import IServiceProvider
+from orionis.container.contracts.container import IContainer
+
+class IApplication(IContainer):
+    """
+    Abstract interface for application containers that manage service providers.
+
+    This interface extends IContainer to provide application-level functionality
+    including service provider management and application lifecycle operations.
+
+    By inheriting from IContainer, this interface provides access to all container
+    methods while adding application-specific functionality.
+    """
+
+    @property
+    @abstractmethod
+    def isBooted(self) -> bool:
+        """
+        Check if the application providers have been booted.
+
+        Returns
+        -------
+        bool
+            True if providers are booted, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def load(self, providers: List[Type[IServiceProvider]] = []) -> None:
+        """
+        Load and boot a list of service providers.
+
+        This method registers each provider and then boots all providers.
+
+        Parameters
+        ----------
+        providers : List[Type[IServiceProvider]]
+            List of service provider classes to register and boot
+
+        Returns
+        -------
+        None
+        """
+        pass
+
+    @abstractmethod
+    def getProviders(self) -> List[IServiceProvider]:
+        """
+        Get the list of registered providers.
+
+        Returns
+        -------
+        List[IServiceProvider]
+            The list of registered service providers
+        """
+        pass

{orionis-0.370.0 → orionis-0.372.0}/orionis/foundation/providers/dumper_provider.py

@@ -1,4 +1,4 @@
-from orionis._console.dumper.dump_die import Debug
+from orionis.console.dumper.dump import Debug
 from orionis.console.dumper.contracts.dump import IDebug
 from orionis.container.providers.service_provider import ServiceProvider
 

{orionis-0.370.0 → orionis-0.372.0}/orionis/metadata/framework.py

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

{orionis-0.370.0 → orionis-0.372.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.370.0 → orionis-0.372.0}/orionis.egg-info/SOURCES.txt

@@ -246,6 +246,7 @@ orionis/foundation/config/testing/entities/testing.py
 orionis/foundation/config/testing/enums/__init__.py
 orionis/foundation/config/testing/enums/test_mode.py
 orionis/foundation/contracts/__init__.py
+orionis/foundation/contracts/application.py
 orionis/foundation/contracts/config.py
 orionis/foundation/exceptions/__init__.py
 orionis/foundation/exceptions/integrity.py