orionis 0.587.0__py3-none-any.whl → 0.589.0__py3-none-any.whl

orionis/foundation/application.py

@@ -1912,21 +1912,22 @@ class Application(Container, IApplication):
         """
 
         # Create a local copy of the configuration to avoid mutating the original
-        local_config = self.__config.copy()
+        if not hasattr(self, '_Application__runtime_config') or self.__runtime_config is None:
+            self.__runtime_config = self.__config.copy()
 
         # Remove 'path' from the local copy to ensure path config is not returned here
-        if 'path' in local_config:
-            del local_config['path']
+        if 'path' in self.__runtime_config:
+            del self.__runtime_config['path']
 
         # Ensure the application is booted before accessing configuration
-        if not local_config:
+        if not self.__runtime_config:
             raise OrionisRuntimeError(
                 "Application configuration is not initialized. Please call create() before accessing configuration."
             )
 
         # If no key is provided, return the entire configuration (excluding 'path')
         if key is None:
-            return local_config
+            return self.__runtime_config
 
         # Ensure the key is a string
         if not isinstance(key, str):
@@ -1938,7 +1939,7 @@ class Application(Container, IApplication):
         parts = key.split('.')
 
         # Start with the full config and traverse according to the key parts
-        config_value = local_config
+        config_value = self.__runtime_config
         for part in parts:
             # If the part exists in the current config_value, go deeper
             if isinstance(config_value, dict) and part in config_value:
@@ -1992,10 +1993,11 @@ class Application(Container, IApplication):
         """
 
         # Create a local copy of the path configuration to avoid mutation
-        local_path_config = self.__config.get('path', {}).copy() if self.__config else {}
+        if not hasattr(self, '_Application__runtime_path_config') or self.__runtime_path_config is None:
+            self.__runtime_path_config = self.__config.get('path', {}).copy() if self.__config else {}
 
         # Ensure the application is booted before accessing configuration
-        if not local_path_config:
+        if not self.__runtime_path_config:
             raise OrionisRuntimeError(
                 "Application configuration is not initialized. Please call create() before accessing path configuration."
             )
@@ -2003,7 +2005,7 @@ class Application(Container, IApplication):
         # If no key is provided, return all paths as a dictionary of Path objects
         if key is None:
             path_resolved: Dict[str, Path] = {}
-            for k, v in local_path_config.items():
+            for k, v in self.__runtime_path_config.items():
                 # Convert each path string to a Path object
                 path_resolved[k] = Path(v)
             return path_resolved
@@ -2015,8 +2017,8 @@ class Application(Container, IApplication):
             )
 
         # Direct key match: return the resolved Path object if the key exists
-        if key in local_path_config:
-            return Path(local_path_config[key])
+        if key in self.__runtime_path_config:
+            return Path(self.__runtime_path_config[key])
 
         # If the key is not found, return None
         return None
@@ -2078,7 +2080,7 @@ class Application(Container, IApplication):
             # Mark as booted
             self.__booted = True
 
-            # Load core framework kernels
+            # Load core framework kernels with app booted
             self.__loadFrameworksKernel()
 
             # Retrieve logger and console instances from the container
@@ -2094,4 +2096,41 @@ class Application(Container, IApplication):
             logger.info(boot_message)
 
         # Return the application instance for method chaining
-        return self
+        return self
+
+    def isProduction(
+        self
+    ) -> bool:
+        """
+        Check if the application is running in a production environment.
+
+        This method determines whether the current application environment is set to 'production'.
+        It checks the 'app.env' configuration value to make this determination.
+
+        Returns
+        -------
+        bool
+            True if the application environment is 'production', False otherwise.
+
+        Raises
+        ------
+        OrionisRuntimeError
+            If the application configuration has not been initialized (i.e., if `create()` has not been called).
+
+        Notes
+        -----
+        The environment is typically defined in the application configuration and can be set to values such as 'development', 'testing', or 'production'.
+        This method is useful for conditionally executing code based on the environment, such as enabling/disabling debug features or logging verbosity.
+        """
+
+        # Retrieve the current application environment from configuration
+        app_env = self.config('app.env')
+
+        # Ensure the application is booted before accessing configuration
+        if app_env is None:
+            raise OrionisRuntimeError(
+                "Application configuration is not initialized. Please call create() before checking the environment."
+            )
+
+        # Return True if the environment is 'production', otherwise False
+        return str(app_env).lower() == 'production'

orionis/foundation/config/testing/entities/testing.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, field
-from typing import List
 from orionis.support.entities.base import BaseEntity
 from orionis.foundation.config.testing.enums import ExecutionMode, PersistentDrivers, VerbosityMode
 from orionis.foundation.exceptions import OrionisIntegrityException
@@ -32,8 +31,6 @@ class Testing(BaseEntity):
         Filename pattern to identify test files (default: 'test_*.py').
     test_name_pattern : str or None, optional
         Pattern to match specific test names (default: None).
-    tags : list of str or None, optional
-        List of tags to filter tests (default: empty list).
     persistent : bool, optional
         If True, keep test results persistent (default: False).
     persistent_driver : str or PersistentDrivers, optional
@@ -118,14 +115,6 @@ class Testing(BaseEntity):
         }
     )
 
-    tags: List[str] | None = field(
-        default_factory = lambda: [],
-        metadata = {
-            "description": "A list of tags to filter tests. Default is an empty list.",
-            "default": []
-        }
-    )
-
     persistent: bool = field(
         default = False,
         metadata = {
@@ -255,18 +244,6 @@ class Testing(BaseEntity):
                 f"Invalid type for 'test_name_pattern': {type(self.test_name_pattern).__name__}. It must be a string or None."
             )
 
-        # Validate tags attribute
-        if self.tags is not None:
-            if not isinstance(self.tags, list):
-                raise OrionisIntegrityException(
-                    f"Invalid type for 'tags': {type(self.tags).__name__}. It must be a list of strings or None."
-                )
-            for i, tag in enumerate(self.tags):
-                if not isinstance(tag, str):
-                    raise OrionisIntegrityException(
-                        f"Invalid type for tag at index {i} in 'tags': {type(tag).__name__}. Each tag must be a string."
-                    )
-
         # Validate persistent attribute
         if not isinstance(self.persistent, bool):
             raise OrionisIntegrityException(

orionis/foundation/contracts/application.py

@@ -1245,4 +1245,31 @@ class IApplication(IContainer):
         duplicate initialization. The startup time is calculated and logged
         for performance monitoring purposes.
         """
+        pass
+
+    @abstractmethod
+    def isProduction(
+        self
+    ) -> bool:
+        """
+        Check if the application is running in a production environment.
+
+        This method determines whether the current application environment is set to 'production'.
+        It checks the 'app.env' configuration value to make this determination.
+
+        Returns
+        -------
+        bool
+            True if the application environment is 'production', False otherwise.
+
+        Raises
+        ------
+        OrionisRuntimeError
+            If the application configuration has not been initialized (i.e., if `create()` has not been called).
+
+        Notes
+        -----
+        The environment is typically defined in the application configuration and can be set to values such as 'development', 'testing', or 'production'.
+        This method is useful for conditionally executing code based on the environment, such as enabling/disabling debug features or logging verbosity.
+        """
         pass

orionis/metadata/framework.py

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

orionis/test/contracts/unit_test.py

@@ -7,162 +7,6 @@ from orionis.foundation.config.testing.enums.verbosity import VerbosityMode
 
 class IUnitTest(ABC):
 
-    @abstractmethod
-    def configure(
-        self,
-        *,
-        verbosity: int | VerbosityMode,
-        execution_mode: str | ExecutionMode,
-        max_workers: int,
-        fail_fast: bool,
-        print_result: bool,
-        throw_exception: bool,
-        persistent: bool,
-        persistent_driver: str | PersistentDrivers,
-        web_report: bool
-    ) -> 'IUnitTest':
-        """
-        Configure the unit test runner with the provided options.
-
-        Parameters
-        ----------
-        verbosity : int or VerbosityMode
-            Verbosity level for test output.
-        execution_mode : str or ExecutionMode
-            Execution mode for running tests.
-        max_workers : int
-            Maximum number of worker threads or processes.
-        fail_fast : bool
-            Whether to stop on the first test failure.
-        print_result : bool
-            Whether to print test results to the console.
-        throw_exception : bool
-            Whether to raise exceptions on test failures.
-        persistent : bool
-            Whether to enable persistent storage for test results.
-        persistent_driver : str or PersistentDrivers
-            Persistent storage driver to use.
-        web_report : bool
-            Whether to generate a web-based test report.
-
-        Returns
-        -------
-        IUnitTest
-            The configured unit test runner instance.
-        """
-        pass
-
-    @abstractmethod
-    def discoverTests(
-        self,
-        base_path: str | Path,
-        folder_path: str | List[str],
-        pattern: str,
-        test_name_pattern: Optional[str] = None,
-        tags: Optional[List[str]] = None
-    ) -> 'IUnitTest':
-        """
-        Discover test cases from specified folders using flexible path discovery.
-
-        This method provides a convenient way to discover and load test cases from multiple folders
-        based on various path specifications. It supports wildcard discovery, single folder loading,
-        and multiple folder loading. The method automatically resolves paths relative to the base
-        directory and discovers all folders containing files matching the specified pattern.
-
-        Parameters
-        ----------
-        base_path : str or Path
-            Base directory path for resolving relative folder paths. This serves as the root
-            directory from which all folder searches are conducted.
-        folder_path : str or list of str
-            Specification of folders to search for test cases. Can be:
-            - '*' : Discover all folders containing matching files within base_path
-            - str : Single folder path relative to base_path
-            - list of str : Multiple folder paths relative to base_path
-        pattern : str
-            File name pattern to match test files, supporting wildcards (* and ?).
-            Examples: 'test_*.py', '*_test.py', 'test*.py'
-        test_name_pattern : str, optional
-            Regular expression pattern to filter test method names. Only tests whose
-            names match this pattern will be included. Default is None (no filtering).
-        tags : list of str, optional
-            List of tags to filter tests. Only tests decorated with matching tags
-            will be included. Default is None (no tag filtering).
-
-        Returns
-        -------
-        UnitTest
-            The current UnitTest instance with discovered tests added to the suite,
-            enabling method chaining.
-
-        Notes
-        -----
-        - All paths are resolved as absolute paths relative to the base_path
-        - When folder_path is '*', the method searches recursively through all subdirectories
-        - The method uses the existing discoverTestsInFolder method for actual test discovery
-        - Duplicate folders are automatically eliminated using a set data structure
-        - The method does not validate the existence of specified folders; validation
-          occurs during the actual test discovery process
-        """
-        pass
-
-    @abstractmethod
-    def discoverTestsInFolder(
-        self,
-        *,
-        base_path: str | Path,
-        folder_path: str,
-        pattern: str,
-        test_name_pattern: Optional[str] = None,
-        tags: Optional[List[str]] = None
-    ) -> 'IUnitTest':
-        """
-        Discover test cases within a specified folder.
-
-        Parameters
-        ----------
-        base_path : str or Path
-            Base directory for test discovery.
-        folder_path : str
-            Path to the folder containing test files.
-        pattern : str
-            File pattern to match test files.
-        test_name_pattern : str, optional
-            Pattern to match test function or class names.
-        tags : list of str, optional
-            Tags to filter discovered tests.
-
-        Returns
-        -------
-        IUnitTest
-            The unit test runner instance with discovered tests.
-        """
-        pass
-
-    @abstractmethod
-    def discoverTestsInModule(
-        self,
-        *,
-        module_name: str,
-        test_name_pattern: Optional[str] = None
-    ) -> 'IUnitTest':
-        """
-        Discover test cases within a specified module.
-
-        Parameters
-        ----------
-        module_name : str
-            Name of the module to search for tests.
-        test_name_pattern : str, optional
-            Pattern to match test function or class names.
-
-        Returns
-        -------
-        IUnitTest
-            The unit test runner instance with discovered tests.
-        """
-        pass
-
     @abstractmethod
     def run(self) -> Dict[str, Any]:
         """