orionis 0.252.0__py3-none-any.whl → 0.265.0__py3-none-any.whl

orionis/luminate/foundation/config/startup.py

@@ -0,0 +1,203 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.app.entities.app import App
+from orionis.luminate.foundation.config.auth.entities.auth import Auth
+from orionis.luminate.foundation.config.cache.entities.cache import Cache
+from orionis.luminate.foundation.config.cors.entities.cors import Cors
+from orionis.luminate.foundation.config.database.entities.database import Database
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.filesystems.entitites.filesystems import Filesystems
+from orionis.luminate.foundation.config.logging.entities.logging import Logging
+from orionis.luminate.foundation.config.mail.entities.mail import Mail
+from orionis.luminate.foundation.config.queue.entities.queue import Queue
+from orionis.luminate.foundation.config.roots.paths import Paths
+from orionis.luminate.foundation.config.session.entities.session import Session
+from orionis.luminate.foundation.config.testing.entities.testing import Testing
+
+@dataclass
+class Configuration:
+    """
+    Configuration class encapsulates all major configuration sections for the application.
+    Attributes:
+        paths (Paths): Paths configuration settings.
+        app (App): Application configuration settings.
+        auth (Auth): Authentication configuration settings.
+        cache (Cache): Cache configuration settings.
+        cors (Cors): CORS configuration settings.
+        database (Database): Database configuration settings.
+        filesystems (Filesystems): Filesystem configuration settings.
+        logging (Logging): Logging configuration settings.
+        mail (Mail): Mail configuration settings.
+        queue (Queue): Queue configuration settings.
+        session (Session): Session configuration settings.
+        testing (Testing): Testing configuration settings.
+    """
+    paths : Paths = field(
+        default_factory=Paths,
+        metadata={
+            "description": "Paths configuration settings."
+        }
+    )
+
+    app : App = field(
+        default_factory=App,
+        metadata={
+            "description": "Application configuration settings."
+        }
+    )
+
+    auth : Auth = field(
+        default_factory=Auth,
+        metadata={
+            "description": "Authentication configuration settings."
+        }
+    )
+
+    cache : Cache = field(
+        default_factory=Cache,
+        metadata={
+            "description": "Cache configuration settings."
+        }
+    )
+
+    cors : Cors = field(
+        default_factory=Cors,
+        metadata={
+            "description": "CORS configuration settings."
+        }
+    )
+
+    database : Database = field(
+        default_factory=Database,
+        metadata={
+            "description": "Database configuration settings."
+        }
+    )
+
+    filesystems : Filesystems = field(
+        default_factory=Filesystems,
+        metadata={
+            "description": "Filesystem configuration settings."
+        }
+    )
+
+    logging : Logging = field(
+        default_factory=Logging,
+        metadata={
+            "description": "Logging configuration settings."
+        }
+    )
+
+    mail : Mail = field(
+        default_factory=Mail,
+        metadata={
+            "description": "Mail configuration settings."
+        }
+    )
+
+    queue : Queue = field(
+        default_factory=Queue,
+        metadata={
+            "description": "Queue configuration settings."
+        }
+    )
+
+    session : Session = field(
+        default_factory=Session,
+        metadata={
+            "description": "Session configuration settings."
+        }
+    )
+
+    testing : Testing = field(
+        default_factory=Testing,
+        metadata={
+            "description": "Testing configuration settings."
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validates the types of the configuration attributes after initialization.
+        Raises:
+            OrionisIntegrityException: If any of the following attributes are not instances of their expected types:
+                - paths (Paths)
+                - app (App)
+                - auth (Auth)
+                - cache (Cache)
+                - cors (Cors)
+                - database (Database)
+                - filesystems (Filesystems)
+                - logging (Logging)
+                - mail (Mail)
+                - queue (Queue)
+                - session (Session)
+                - testing (Testing)
+        """
+
+        if not isinstance(self.paths, Paths):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'paths': expected Paths, got {type(self.paths).__name__}"
+            )
+
+        if not isinstance(self.app, App):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'app': expected App, got {type(self.app).__name__}"
+            )
+
+        if not isinstance(self.auth, Auth):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'auth': expected Auth, got {type(self.auth).__name__}"
+            )
+
+        if not isinstance(self.cache, Cache):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'cache': expected Cache, got {type(self.cache).__name__}"
+            )
+
+        if not isinstance(self.cors, Cors):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'cors': expected Cors, got {type(self.cors).__name__}"
+            )
+
+        if not isinstance(self.database, Database):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'database': expected Database, got {type(self.database).__name__}"
+            )
+
+        if not isinstance(self.filesystems, Filesystems):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'filesystems': expected Filesystems, got {type(self.filesystems).__name__}"
+            )
+
+        if not isinstance(self.logging, Logging):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'logging': expected Logging, got {type(self.logging).__name__}"
+            )
+
+        if not isinstance(self.mail, Mail):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'mail': expected Mail, got {type(self.mail).__name__}"
+            )
+
+        if not isinstance(self.queue, Queue):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'queue': expected Queue, got {type(self.queue).__name__}"
+            )
+
+        if not isinstance(self.session, Session):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'session': expected Session, got {type(self.session).__name__}"
+            )
+
+        if not isinstance(self.testing, Testing):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'testing': expected Testing, got {type(self.testing).__name__}"
+            )
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)

orionis/luminate/{config → foundation/config/testing}/entities/testing.py

@@ -1,17 +1,10 @@
-from dataclasses import dataclass, field
-from typing import Any, List
-from orionis.luminate.config.exceptions.integrity_exception import OrionisIntegrityException
-from orionis.luminate.services.workers.maximum_workers import MaximumWorkers
+from dataclasses import asdict, dataclass, field
+from typing import List
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.services.system.workers import Workers
+from orionis.luminate.test.enums.test_mode import ExecutionMode
 
-def defaultExecutionMode() -> Any:
-    """
-    This function is a placeholder for the ExecutionMode enumeration.
-    In a real-world scenario, this would be replaced with the actual import statement.
-    """
-    from orionis.luminate.test.enums.test_mode import ExecutionMode
-    return ExecutionMode.SEQUENTIAL
-
-@dataclass(frozen=True, kw_only=True, slots=True)
+@dataclass(unsafe_hash=True, kw_only=True)
 class Testing:
     """
     Testing is a dataclass that holds configuration options for running tests.
@@ -34,6 +27,7 @@ class Testing:
         test_name_pattern (str | None): A pattern to match specific test names. Default is None.
         tags (List[str] | None): A list of tags to filter tests. Default is None.
     """
+
     verbosity: int = field(
         default=2,
         metadata={
@@ -43,21 +37,21 @@ class Testing:
         }
     )
 
-    execution_mode : Any = field(
-        default_factory=lambda: defaultExecutionMode(),
+    execution_mode : str | ExecutionMode = field(
+        default=ExecutionMode.SEQUENTIAL,
         metadata={
-            "description": "The mode of test execution. Default is ExecutionMode.SEQUENTIAL.",
+            "description": "The mode of test execution. Default is ExecutionMode.SEQUENTIAL",
             "required": True,
             "default": "ExecutionMode.SEQUENTIAL"
         }
     )
 
     max_workers: int = field(
-        default_factory=lambda : MaximumWorkers().calculate(),
+        default_factory=lambda : Workers().calculate(),
         metadata={
             "description": "The maximum number of worker threads/processes to use when running tests in parallel. Default is 4.",
             "required": True,
-            "default": "MaximumWorkers.calculate()"
+            "default": "Workers.calculate()"
         }
     )
 
@@ -147,16 +141,29 @@ class Testing:
         Raises:
             OrionisIntegrityException: If any of the attributes do not meet the specified constraints.
         """
+
         if not isinstance(self.verbosity, int) or self.verbosity < 0 or self.verbosity > 2:
             raise OrionisIntegrityException(
                 f"Invalid value for 'verbosity': {self.verbosity}. It must be an integer between 0 (silent) and 2 (detailed output)."
             )
 
-        if self.execution_mode is None:
+        if not isinstance(self.execution_mode, (str, ExecutionMode)):
             raise OrionisIntegrityException(
-                "'execution_mode' cannot be None. Please provide a valid ExecutionMode value."
+                f"Invalid type for 'execution_mode': {type(self.execution_mode).__name__}. It must be a string or an instance of ExecutionMode."
             )
 
+        if isinstance(self.execution_mode, str):
+            options_modes = ExecutionMode._member_names_
+            _value = str(self.execution_mode).upper().strip()
+            if _value not in options_modes:
+                raise OrionisIntegrityException(
+                    f"Invalid value for 'execution_mode': {self.execution_mode}. It must be one of: {str(options_modes)}."
+                )
+            else:
+                self.execution_mode = ExecutionMode[_value].value
+        elif isinstance(self.execution_mode, ExecutionMode):
+            self.execution_mode = self.execution_mode.value
+
         if not isinstance(self.max_workers, int) or self.max_workers < 1:
             raise OrionisIntegrityException(
                 f"Invalid value for 'max_workers': {self.max_workers}. It must be a positive integer greater than 0."
@@ -213,3 +220,12 @@ class Testing:
                     raise OrionisIntegrityException(
                         f"Invalid type for tag at index {i} in 'tags': {type(tag).__name__}. Each tag must be a string."
                     )
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)
+

orionis/luminate/foundation/config/testing/enums/test_mode.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class ExecutionMode(Enum):
+    """
+    Enumeration of possible execution modes for running tests.
+
+    Attributes:
+        SEQUENTIAL: Execute tests one after another in sequence.
+        PARALLEL: Execute tests concurrently in parallel.
+    """
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"

orionis/luminate/patterns/__init__.py

@@ -1,4 +0,0 @@
-__description__ = (
-    "Modules:\n"
-    "  - singleton: Provides a singleton metaclass to ensure a class has only one instance.\n"
-)

orionis/luminate/patterns/singleton/__init__.py

@@ -1,10 +0,0 @@
-from orionis.luminate.patterns.singleton.meta_class import Singleton
-
-__all__ = [
-    "Singleton",
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "This module provides a singleton class to manage environment variables. "
-    "It allows setting, getting, and deleting environment variables."
-)

orionis/luminate/services/asynchrony/async_io.py

@@ -0,0 +1,31 @@
+import asyncio
+from typing import Any, Coroutine, TypeVar, Union
+
+T = TypeVar("T")
+
+def run_coroutine(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]:
+    """
+    Executes the given coroutine object, adapting to the current execution context.
+    If there is an active event loop, it uses `asyncio.ensure_future` to schedule the coroutine.
+    If there is no active event loop, it uses `asyncio.run` to run the coroutine directly.
+    If the coroutine is already running, it returns a `Future` object that can be awaited.
+
+    Parameters
+    ----------
+    coro : Coroutine[Any, Any, T]
+        The coroutine object
+    """
+    from inspect import iscoroutine
+
+    if not iscoroutine(coro):
+        raise TypeError("Expected a coroutine object.")
+
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+
+    if loop.is_running():
+        return asyncio.ensure_future(coro)
+    else:
+        return loop.run_until_complete(coro)

orionis/luminate/services/environment/__init__.py

@@ -1,10 +0,0 @@
-from orionis.luminate.services.environment.env import Env
-
-__all__ = [
-    "Env",
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "This module provides a singleton class to manage environment variables. "
-    "It allows setting, getting, and deleting environment variables."
-)

orionis/luminate/services/environment/contracts/__init__.py

@@ -1,5 +0,0 @@
-from orionis.luminate.services.environment.dot_env import DotEnv
-
-__all__ = [
-    "DotEnv",
-]

orionis/luminate/services/environment/contracts/env.py

@@ -59,17 +59,6 @@ class IEnv(ABC):
         """
         pass
 
-    @staticmethod
-    @abstractmethod
-    def destroy() -> bool:
-        """
-        Clears the entire environment.
-
-        Returns:
-            True if successful, False otherwise
-        """
-        pass
-
     @staticmethod
     @abstractmethod
     def toJson() -> str: