orionis 0.588.0__py3-none-any.whl → 0.590.0__py3-none-any.whl

orionis/console/core/reactor.py

@@ -850,7 +850,8 @@ class Reactor(IReactor):
                 output = self.__app.call(command_instance, command.method)
 
                 # Calculate elapsed time and log completion with DONE state if command.timestamps are enabled
-                elapsed_time = round(self.__performance_counter.stop(), 2)
+                self.__performance_counter.stop()
+                elapsed_time = round(self.__performance_counter.getSeconds(), 2)
                 if command.timestamps:
                     self.__executer.done(program=signature, time=f"{elapsed_time}s")
 
@@ -866,7 +867,8 @@ class Reactor(IReactor):
                 self.__logger.error(f"Command '{signature}' execution failed: {e}")
 
                 # Calculate elapsed time and log failure with ERROR state if command.timestamps are enabled
-                elapsed_time = round(self.__performance_counter.stop(), 2)
+                self.__performance_counter.stop()
+                elapsed_time = round(self.__performance_counter.getSeconds(), 2)
                 if command.timestamps:
                     self.__executer.fail(program=signature, time=f"{elapsed_time}s")
 

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.588.0"
+VERSION = "0.590.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/support/performance/contracts/counter.py

@@ -9,7 +9,7 @@ class IPerformanceCounter(ABC):
     """
 
     @abstractmethod
-    def start(self) -> float:
+    def start(self) -> 'IPerformanceCounter':
         """
         Start the performance counter.
 
@@ -18,13 +18,13 @@ class IPerformanceCounter(ABC):
 
         Returns
         -------
-        float
-            The timestamp (in fractional seconds) at which the counter was started.
+        IPerformanceCounter
+            The instance of the performance counter for method chaining.
         """
         pass
 
     @abstractmethod
-    def stop(self) -> float:
+    def stop(self) -> 'IPerformanceCounter':
         """
         Stop the performance counter and calculate the elapsed time.
 
@@ -32,9 +32,106 @@ class IPerformanceCounter(ABC):
         the elapsed time since `start()` was called. The elapsed time is the
         difference between the end and start timestamps.
 
+        Returns
+        -------
+        IPerformanceCounter
+            The instance of the performance counter for method chaining.
+        """
+        pass
+
+    @abstractmethod
+    def elapsedTime(self) -> float:
+        """
+        Get the elapsed time between the last start and stop calls.
+
+        This method returns the elapsed time calculated during the last
+        `stop()` call. If the counter has not been started and stopped,
+        it raises an exception.
+
+        Returns
+        -------
+        float
+            The elapsed time in seconds (as a float) between the last `start()` and `stop()` calls.
+
+        Raises
+        ------
+        ValueError
+            If the counter has not been started and stopped properly.
+        """
+        pass
+
+    @abstractmethod
+    def getMicroseconds(self) -> float:
+        """
+        Get the elapsed time in microseconds.
+
+        This method returns the elapsed time in microseconds by converting
+        the value obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in microseconds (as a float).
+        """
+        pass
+
+    @abstractmethod
+    def getMilliseconds(self) -> float:
+        """
+        Get the elapsed time in milliseconds.
+
+        This method returns the elapsed time in milliseconds by converting
+        the value obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in milliseconds (as a float).
+        """
+        pass
+
+    @abstractmethod
+    def getSeconds(self) -> float:
+        """
+        Get the elapsed time in seconds.
+
+        This method returns the elapsed time in seconds, which is the same
+        value as obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in seconds (as a float).
+        """
+        pass
+
+    @abstractmethod
+    def getMinutes(self) -> float:
+        """
+        Get the elapsed time in minutes.
+
+        This method returns the elapsed time in minutes by converting
+        the value obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in minutes (as a float).
+        """
+        pass
+
+    @abstractmethod
+    def restart(self) -> float:
+        """
+        Restart the performance counter.
+
+        This method resets the start and end times to None and starts the counter again.
+        It is useful for measuring a new interval without creating a new instance of
+        PerformanceCounter.
+
         Returns
         -------
         float
-            The elapsed time in seconds (as a float) between when `start()` and `stop()` were called.
+            The timestamp (in fractional seconds) at which the counter was restarted.
         """
         pass

orionis/support/performance/counter.py

@@ -49,7 +49,10 @@ class PerformanceCounter(IPerformanceCounter):
         # Time when the counter is stopped; initialized to None
         self.__end_time = None
 
-    def start(self) -> float:
+        # Difference between end time and start time; initialized to None
+        self.__diff_time = None
+
+    def start(self) -> 'PerformanceCounter':
         """
         Start the performance counter.
 
@@ -58,15 +61,15 @@ class PerformanceCounter(IPerformanceCounter):
 
         Returns
         -------
-        float
-            The timestamp (in fractional seconds) at which the counter was started.
+        IPerformanceCounter
+            The instance of the performance counter for method chaining.
         """
 
         # Record the current time as the start time
         self.__start_time = time.perf_counter()
-        return self.__start_time
+        return self
 
-    def stop(self) -> float:
+    def stop(self) -> 'PerformanceCounter':
         """
         Stop the performance counter and calculate the elapsed time.
 
@@ -76,12 +79,119 @@ class PerformanceCounter(IPerformanceCounter):
 
         Returns
         -------
-        float
-            The elapsed time in seconds (as a float) between when `start()` and `stop()` were called.
+        IPerformanceCounter
+            The instance of the performance counter for method chaining.
         """
 
         # Record the current time as the end time
         self.__end_time = time.perf_counter()
 
         # Calculate and return the elapsed time
-        return self.__end_time - self.__start_time
+        self.__diff_time = self.__end_time - self.__start_time
+        return self
+
+    def elapsedTime(self) -> float:
+        """
+        Get the elapsed time between the last start and stop calls.
+
+        This method returns the elapsed time calculated during the last
+        `stop()` call. If the counter has not been started and stopped,
+        it raises an exception.
+
+        Returns
+        -------
+        float
+            The elapsed time in seconds (as a float) between the last `start()` and `stop()` calls.
+
+        Raises
+        ------
+        ValueError
+            If the counter has not been started and stopped properly.
+        """
+
+        if self.__diff_time is None:
+            raise ValueError("Counter has not been started and stopped properly.")
+
+        return self.__diff_time
+
+    def getMicroseconds(self) -> float:
+        """
+        Get the elapsed time in microseconds.
+
+        This method returns the elapsed time in microseconds by converting
+        the value obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in microseconds (as a float).
+        """
+
+        return self.elapsedTime() * 1_000_000
+
+    def getMilliseconds(self) -> float:
+        """
+        Get the elapsed time in milliseconds.
+
+        This method returns the elapsed time in milliseconds by converting
+        the value obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in milliseconds (as a float).
+        """
+
+        return self.elapsedTime() * 1_000
+
+    def getSeconds(self) -> float:
+        """
+        Get the elapsed time in seconds.
+
+        This method returns the elapsed time in seconds, which is the same
+        value as obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in seconds (as a float).
+        """
+
+        return self.elapsedTime()
+
+    def getMinutes(self) -> float:
+        """
+        Get the elapsed time in minutes.
+
+        This method returns the elapsed time in minutes by converting
+        the value obtained from `elapsedTime()`.
+
+        Returns
+        -------
+        float
+            The elapsed time in minutes (as a float).
+        """
+
+        return self.elapsedTime() / 60
+
+    def restart(self) -> float:
+        """
+        Restart the performance counter.
+
+        This method resets the start and end times to None and starts the counter again.
+        It is useful for measuring a new interval without creating a new instance of
+        PerformanceCounter.
+
+        Returns
+        -------
+        float
+            The timestamp (in fractional seconds) at which the counter was restarted.
+        """
+
+        # Reset start and end times
+        self.__start_time = None
+        self.__end_time = None
+        self.__diff_time = None
+
+        # Start the counter again
+        return self.start()

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]:
         """