orionis 0.588.0__tar.gz → 0.590.0__tar.gz

{orionis-0.588.0/orionis.egg-info → orionis-0.590.0}/PKG-INFO

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

{orionis-0.588.0 → orionis-0.590.0}/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-0.588.0 → orionis-0.590.0}/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-0.588.0 → orionis-0.590.0}/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-0.588.0 → orionis-0.590.0}/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-0.588.0 → orionis-0.590.0}/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-0.590.0/orionis/support/performance/contracts/counter.py

@@ -0,0 +1,137 @@
+from abc import ABC, abstractmethod
+
+class IPerformanceCounter(ABC):
+    """
+    A class for measuring the elapsed time between two points in code execution.
+
+    This class provides methods to start and stop a high-resolution performance counter,
+    allowing users to measure the duration of specific code segments with precision.
+    """
+
+    @abstractmethod
+    def start(self) -> 'IPerformanceCounter':
+        """
+        Start the performance counter.
+
+        Records the current high-resolution time as the start time using
+        `time.perf_counter()`. This marks the beginning of the interval to be measured.
+
+        Returns
+        -------
+        IPerformanceCounter
+            The instance of the performance counter for method chaining.
+        """
+        pass
+
+    @abstractmethod
+    def stop(self) -> 'IPerformanceCounter':
+        """
+        Stop the performance counter and calculate the elapsed time.
+
+        Records the current high-resolution time as the end time and computes
+        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 timestamp (in fractional seconds) at which the counter was restarted.
+        """
+        pass

orionis-0.590.0/orionis/support/performance/counter.py

@@ -0,0 +1,197 @@
+import time
+from orionis.support.performance.contracts.counter import IPerformanceCounter
+
+class PerformanceCounter(IPerformanceCounter):
+    """
+    A class for measuring the elapsed time between two points in code execution.
+
+    This class provides methods to start and stop a high-resolution performance counter,
+    allowing users to measure the duration of specific code segments with precision.
+
+    Attributes
+    ----------
+    __start_time : float or None
+        The timestamp when the counter was started.
+    __end_time : float or None
+        The timestamp when the counter was stopped.
+
+    Methods
+    -------
+    start()
+        Starts the performance counter.
+    stop()
+        Stops the performance counter and returns the elapsed time.
+
+    Notes
+    -----
+    The counter uses `time.perf_counter()` for high-resolution timing.
+    """
+
+    def __init__(self):
+        """
+        Initialize a new PerformanceCounter instance.
+
+        This constructor sets the internal start and end time attributes to None,
+        preparing the counter for use. The counter can then be started and stopped
+        to measure elapsed time between two points in code execution.
+
+        Attributes
+        ----------
+        __start_time : float or None
+            The timestamp when the counter is started, or None if not started.
+        __end_time : float or None
+            The timestamp when the counter is stopped, or None if not stopped.
+        """
+
+        # Time when the counter is started; initialized to None
+        self.__start_time = None
+
+        # Time when the counter is stopped; initialized to None
+        self.__end_time = None
+
+        # Difference between end time and start time; initialized to None
+        self.__diff_time = None
+
+    def start(self) -> 'PerformanceCounter':
+        """
+        Start the performance counter.
+
+        Records the current high-resolution time as the start time using
+        `time.perf_counter()`. This marks the beginning of the interval to be measured.
+
+        Returns
+        -------
+        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
+
+    def stop(self) -> 'PerformanceCounter':
+        """
+        Stop the performance counter and calculate the elapsed time.
+
+        Records the current high-resolution time as the end time and computes
+        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.
+        """
+
+        # Record the current time as the end time
+        self.__end_time = time.perf_counter()
+
+        # Calculate and return the elapsed 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-0.590.0/orionis/test/contracts/unit_test.py

@@ -0,0 +1,101 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from orionis.foundation.config.testing.enums import ExecutionMode
+from orionis.foundation.config.testing.enums.drivers import PersistentDrivers
+from orionis.foundation.config.testing.enums.verbosity import VerbosityMode
+
+class IUnitTest(ABC):
+
+    @abstractmethod
+    def run(self) -> Dict[str, Any]:
+        """
+        Execute all discovered tests.
+
+        Returns
+        -------
+        dict
+            Results of the test execution.
+        """
+        pass
+
+    @abstractmethod
+    def getTestNames(self) -> List[str]:
+        """
+        Retrieve the list of discovered test names.
+
+        Returns
+        -------
+        list of str
+            Names of all discovered tests.
+        """
+        pass
+
+    @abstractmethod
+    def getTestCount(self) -> int:
+        """
+        Get the total number of discovered tests.
+
+        Returns
+        -------
+        int
+            Number of discovered tests.
+        """
+        pass
+
+    @abstractmethod
+    def clearTests(self) -> None:
+        """
+        Remove all discovered tests from the runner.
+        """
+        pass
+
+    @abstractmethod
+    def getResult(self) -> dict:
+        """
+        Retrieve the results of the last test run.
+
+        Returns
+        -------
+        dict
+            Results of the last test execution.
+        """
+        pass
+
+    @abstractmethod
+    def getOutputBuffer(self) -> int:
+        """
+        Get the size or identifier of the output buffer.
+
+        Returns
+        -------
+        int
+            Output buffer size or identifier.
+        """
+        pass
+
+    @abstractmethod
+    def printOutputBuffer(self) -> None:
+        """
+        Print the contents of the output buffer to the console.
+        """
+        pass
+
+    @abstractmethod
+    def getErrorBuffer(self) -> int:
+        """
+        Get the size or identifier of the error buffer.
+
+        Returns
+        -------
+        int
+            Error buffer size or identifier.
+        """
+        pass
+
+    @abstractmethod
+    def printErrorBuffer(self) -> None:
+        """
+        Print the contents of the error buffer to the console.
+        """
+        pass