orionis 0.30.0__tar.gz → 0.34.0__tar.gz

{orionis-0.30.0/orionis.egg-info → orionis-0.34.0}/PKG-INFO

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

{orionis-0.30.0 → orionis-0.34.0}/orionis/framework.py

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

orionis-0.34.0/orionis/luminate/app.py

@@ -0,0 +1,26 @@
+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 App(metaclass=SingletonMeta):
+
+    def __init__(self):
+        self.container = Container()
+
+    def start(self):
+        self._register_config_providers()
+        self._resolve_config_providers()
+
+    def finish(self):
+        self.container = None
+
+    def _register_config_providers(self):
+        self.container.singleton(CacheConfig)
+        self.container.singleton(Register)
+        self.container.singleton(Bootstrapper)
+
+    def _resolve_config_providers(self):
+        self.container.make(Register)
+        self.container.make(Bootstrapper)

{orionis-0.30.0 → orionis-0.34.0}/orionis/luminate/console/output/console.py

@@ -442,15 +442,17 @@ class Console(IConsole):
         """
 
         errors = ExceptionsToDict.parse(e)
-        error_type = errors.get("error_type")
-        error_message = errors.get("error_message")
+        error_type = errors.get("error_type").split(".")[-1]
+        error_message = errors.get("error_message").replace(error_type, "").replace("[]", "").strip()
         stack_trace = errors.get("stack_trace")
 
         # Format the output with a more eye-catching appearance
-        message = f"{ANSIColors.BG_ERROR.value}{ANSIColors.TEXT_WHITE.value} [{error_type}] {ANSIColors.TEXT_RESET.value}: {ANSIColors.TEXT_WARNING.value}{error_message}{ANSIColors.TEXT_RESET.value}"
-        print("-" * len(f" [{error_type}] : {error_message}"))  # separator line
+        message = f"{ANSIColors.BG_ERROR.value}{ANSIColors.TEXT_WHITE.value}[{error_type}]{ANSIColors.TEXT_RESET.value}: {ANSIColors.TEXT_WARNING.value}{error_message}{ANSIColors.TEXT_RESET.value}"
+        print("▬" * len(f" [{error_type}] : {error_message}"))
         print(message)
 
+        real_count = len(stack_trace)
+        count_error = real_count
         for frame in stack_trace:
             filename = frame["filename"]
             lineno = frame["lineno"]
@@ -458,6 +460,8 @@ class Console(IConsole):
             line = frame["line"]
 
             # Print the stack trace with enhanced styling
-            print(f"{ANSIColors.CYAN.value}{ANSIColors.DIM.value}  {ANSIColors.MAGENTA.value}{ANSIColors.TEXT_BOLD.value}{filename}:{ANSIColors.TEXT_BOLD.value}{lineno}{ANSIColors.TEXT_RESET.value} / {ANSIColors.DIM.value}{ANSIColors.ITALIC.value}{ANSIColors.TEXT_WARNING.value}{name}{ANSIColors.TEXT_RESET.value} / {ANSIColors.CYAN.value}{line}{ANSIColors.TEXT_RESET.value}")
+            print(f"{ANSIColors.TEXT_MUTED.value}Trace Call ({count_error}/{real_count}){ANSIColors.TEXT_RESET.value} - {ANSIColors.TEXT_WHITE.value}{filename}:{lineno}{ANSIColors.TEXT_RESET.value}")
+            print(f"  {ANSIColors.DIM.value}{ANSIColors.ITALIC.value}{ANSIColors.TEXT_WARNING.value}{name}{ANSIColors.TEXT_RESET.value} : {ANSIColors.CYAN.value}{line}{ANSIColors.TEXT_RESET.value}")
+            count_error -= 1
 
-        print("-" * len(f" [{error_type}] : {error_message}"))
+        print("▬" * len(f" [{error_type}] : {error_message}"))

{orionis-0.30.0 → orionis-0.34.0}/orionis/luminate/container/container.py

@@ -5,6 +5,7 @@ from typing import Callable, Any, Dict
 from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerValueError, OrionisContainerTypeError
 from orionis.luminate.container.types import Types
 from orionis.luminate.contracts.container.container_interface import IContainer
+from orionis.luminate.patterns.singleton import SingletonMeta
 
 BINDING = 'binding'
 TRANSIENT = 'transient'
@@ -12,7 +13,7 @@ SINGLETON = 'singleton'
 SCOPED = 'scoped'
 INSTANCE = 'instance'
 
-class Container(IContainer):
+class Container(IContainer, metaclass=SingletonMeta):
     """
     Service container and dependency injection manager.
 
@@ -20,23 +21,15 @@ class Container(IContainer):
     and different lifecycle types such as transient, singleton, and scoped.
     """
 
-    _instance = None
-    _lock = Lock()
-
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._bindings = {}
-                    cls._instance._transients = {}
-                    cls._instance._singletons = {}
-                    cls._instance._scoped_services = {}
-                    cls._instance._instances = {}
-                    cls._instance._aliases = {}
-                    cls._instance._scoped_instances = {}
-                    cls._instance._validate_types = Types()
-        return cls._instance
+    def __init__(self):
+        self._bindings = {}
+        self._transients = {}
+        self._singletons = {}
+        self._scoped_services = {}
+        self._instances = {}
+        self._aliases = {}
+        self._scoped_instances = {}
+        self._validate_types = Types()
 
     def _newRequest(self) -> None:
         """
@@ -312,7 +305,17 @@ class Container(IContainer):
         OrionisContainerException
             If the service is not found in the container.
         """
-        key = self._aliases.get(abstract, abstract)
+
+        key = abstract
+
+        if isinstance(abstract, str):
+            key = self._aliases.get(key, key)
+
+        if callable(abstract):
+            key = f"{abstract.__module__}.{abstract.__name__}"
+
+        if isinstance(abstract, object) and abstract.__class__.__module__ not in {'builtins', 'abc'}:
+            key = f"{abstract.__class__.__module__}.{abstract.__class__.__name__}"
 
         if key in self._instances:
             return self._instances[key]['instance']

{orionis-0.30.0 → orionis-0.34.0}/orionis/luminate/orionis.py

@@ -1,7 +1,8 @@
 import traceback
 from orionis.luminate.app import App
+from orionis.luminate.patterns.singleton import SingletonMeta
 
-class OrionisContext:
+class Orionis(metaclass=SingletonMeta):
     """
     Context manager for the Orionis application that handles startup and cleanup.
 
@@ -87,7 +88,7 @@ class OrionisContext:
             self.error_info = (exc_val, traceback.format_exc())
             return False
 
-    def is_active(self):
+    def isStarted(self):
         """
         Check if the application is currently active.
 
@@ -98,7 +99,7 @@ class OrionisContext:
         """
         return self.is_started
 
-    def get_error(self):
+    def getError(self):
         """
         Retrieve the stored error information.
 

orionis-0.34.0/orionis/luminate/patterns/singleton.py

@@ -0,0 +1,44 @@
+import threading
+
+class SingletonMeta(type):
+    """
+    A thread-safe metaclass for implementing the Singleton pattern.
+
+    This metaclass ensures that only one instance of a class is created,
+    even in a multithreaded environment, by using a lock to synchronize
+    instance creation.
+
+    Attributes
+    ----------
+    _instances : dict
+        A dictionary that holds the single instances of the classes using this metaclass.
+    _lock : threading.Lock
+        A lock to ensure thread-safe instance creation.
+    """
+    _instances = {}
+    _lock = threading.Lock()
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Return the singleton instance of the class in a thread-safe manner.
+
+        If an instance does not already exist, it is created under the protection
+        of a lock; otherwise, the existing instance is returned.
+
+        Parameters
+        ----------
+        *args : list
+            Positional arguments for the class constructor.
+        **kwargs : dict
+            Keyword arguments for the class constructor.
+
+        Returns
+        -------
+        object
+            The singleton instance of the class.
+        """
+        if cls not in cls._instances:
+            with cls._lock:
+                if cls not in cls._instances:
+                    cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]

{orionis-0.30.0 → orionis-0.34.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.30.0 → orionis-0.34.0}/orionis.egg-info/SOURCES.txt

@@ -133,6 +133,7 @@ orionis/luminate/installer/setup.py
 orionis/luminate/installer/upgrade.py
 orionis/luminate/log/__init__.py
 orionis/luminate/log/logger.py
+orionis/luminate/patterns/singleton.py
 orionis/luminate/pipelines/__init__.py
 orionis/luminate/pipelines/cli_pipeline.py
 orionis/luminate/publisher/__init__.py

orionis-0.30.0/orionis/luminate/app.py

@@ -1,36 +0,0 @@
-from orionis.luminate.container.container import Container
-
-class App:
-
-    def __init__(self):
-        # Inicializa el contenedor de dependencias
-        self.container = Container()
-
-    def start(self):
-        pass
-
-    def finish(self):
-        pass
-
-    def in_context(self):
-        """Método placeholder para gestionar el contexto de la aplicación"""
-        pass
-
-    def register_service_providers(self):
-        """
-        Registra los proveedores de servicios en el contenedor.
-        Carga y registra los servicios de forma perezosa.
-        """
-        # Importación perezosa de los servicios
-        from orionis.luminate.cache.app.config import CacheConfig
-        from orionis.luminate.bootstrap.config.register import Register
-        from orionis.luminate.bootstrap.config.bootstrapper import Bootstrapper
-
-        # Registro de servicios esenciales en el contenedor
-        self.container.singleton(CacheConfig)  # Configuración del cache
-        self.container.singleton(Register)    # Registro de la configuración de la app
-        self.container.singleton(Bootstrapper)  # Inicialización del sistema
-
-    def load_config(self):
-        """Método placeholder para cargar la configuración de la aplicación"""
-        pass