orionis 0.431.0__py3-none-any.whl → 0.434.0__py3-none-any.whl

orionis/app.py

@@ -0,0 +1,17 @@
+from orionis.foundation.application import Application, IApplication
+
+def Orionis() -> IApplication:
+    """
+    Initialize and return the main Orionis application instance.
+
+    Initializes the core application object that implements the `IApplication` interface.
+    This function acts as the entry point for creating and accessing the main application instance.
+
+    Returns
+    -------
+    IApplication
+        The initialized application instance implementing the `IApplication` interface.
+    """
+
+    # Instantiate and return the main application object
+    return Application()

orionis/console/commands/version.py

@@ -9,9 +9,9 @@ class VersionCommand(BaseCommand):
     This command prints the version number of the framework in use.
     """
 
-    signature = "version"
+    signature: str = "version"
 
-    description = "Prints the version of the framework in use."
+    description: str = "Prints the version of the framework in use."
 
     def handle(self) -> None:
         """

orionis/console/core/reactor.py

@@ -1,4 +1,4 @@
 class Reactor:
 
     def __init__(self):
-        self._reactors = {}
+        self.__reactors = {}

orionis/foundation/config/roots/paths.py

@@ -7,10 +7,10 @@ from orionis.support.entities.base import BaseEntity
 class Paths(BaseEntity):
 
     console_scheduler: str = field(
-        default_factory = lambda: str((Path.cwd() / 'app' / 'console' / 'kernel.py').resolve()),
+        default_factory = lambda: str((Path.cwd() / 'app' / 'console' / 'scheduler.py').resolve()),
         metadata = {
             'description': 'Path to the console scheduler (Kernel) file.',
-            'default': lambda: str((Path.cwd() / 'app' / 'console' / 'kernel.py').resolve())
+            'default': lambda: str((Path.cwd() / 'app' / 'console' / 'scheduler.py').resolve())
         }
     )
 

orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.431.0"
+VERSION = "0.434.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"
@@ -42,38 +42,24 @@ PYTHON_REQUIRES = ">=3.12"
 #---------------------------------------------------------------------------
 # List of classifiers that provide metadata about the project for PyPI and other tools.
 CLASSIFIERS = [
-    ("Development Status", "3 - Alpha"),
-    ("Environment", "Web Environment"),
-    ("Intended Audience", "Developers"),
-    ("License", "OSI Approved", "MIT License"),
-    ("Operating System", "OS Independent"),
-    ("Programming Language", "Python"),
-    ("Programming Language", "Python", "3"),
-    ("Programming Language", "Python", "3", "Only"),
-    ("Programming Language", "Python", "3.12"),
-    ("Programming Language", "Python", "3.13"),
-    ("Typing", "Typed"),
-    ("Topic", "Internet", "WWW/HTTP"),
-    ("Topic", "Internet", "WWW/HTTP", "Dynamic Content"),
-    ("Topic", "Internet", "WWW/HTTP", "WSGI"),
-    ("Topic", "Software Development", "Libraries", "Application Frameworks"),
-    ("Topic", "Software Development", "Libraries", "Python Modules"),
+    'Development Status :: 3 - Alpha',
+    'Environment :: Web Environment',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: OS Independent',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3 :: Only',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'Typing :: Typed',
+    'Topic :: Internet :: WWW/HTTP',
+    'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
+    'Topic :: Internet :: WWW/HTTP :: WSGI',
+    'Topic :: Software Development :: Libraries :: Application Frameworks',
+    'Topic :: Software Development :: Libraries :: Python Modules'
 ]
 
-def get_classifiers():
-    """
-    Returns the list of classifiers as strings, formatted for use in setup.py or pyproject.toml.
-
-    Each classifier tuple is joined with ' :: ' as required by Python packaging standards.
-
-    Returns:
-        list of str: Classifier strings, e.g., 'Programming Language :: Python :: 3.12'
-    """
-    return [
-        " :: ".join(classtuple)
-        for classtuple in CLASSIFIERS
-    ]
-
 #---------------------------------------------------------------------------
 # Project Keywords
 #---------------------------------------------------------------------------
@@ -92,46 +78,33 @@ KEYWORDS = [
 #---------------------------------------------------------------------------
 # List of required packages and their minimum versions.
 REQUIRES = [
-    ("apscheduler", "3.11.0"),
-    ("python-dotenv", "1.0.1"),
-    ("requests", "2.32.3"),
-    ("rich", "13.9.4"),
-    ("psutil", "7.0.0"),
-    ("cryptography", "44.0.3"),
+    'apscheduler>=3.11.0',
+    'python-dotenv>=1.0.1',
+    'requests>=2.32.3',
+    'rich>=13.9.4',
+    'psutil>=7.0.0',
+    'cryptography>=44.0.3'
 ]
 
-def get_requires():
+#---------------------------------------------------------------------------
+# Function to retrieve the icon SVG code
+#---------------------------------------------------------------------------
+# This function reads the 'icon.svg' file from the current directory and returns its content.
+def icon():
     """
-    Returns the list of required dependencies as strings, formatted for use in requirements files.
+    Returns the SVG code for the project's icon image.
 
-    Each dependency tuple is joined with '>=' to specify the minimum required version.
+    Reads the 'icon.svg' file from the current directory and returns its content.
 
     Returns:
-        list of str: Requirement strings, e.g., 'requests>=2.32.3'
-    """
-    return [
-        ">=".join(requirement)
-        for requirement in REQUIRES
-    ]
-
-def get_svg_assets():
+        str: SVG code as a string, or None if the file is not found.
     """
-    Returns the SVG code for the project's icon and text images.
+    import os
 
-    Reads the SVG files and returns their contents as strings.
+    path = os.path.join(os.path.dirname(__file__), 'icon.svg')
 
-    Returns:
-        dict: Dictionary with 'icon' and 'text' keys containing SVG code as strings.
-    """
-    import os
-    current_dir = os.path.dirname(__file__)
-    icon_path = os.path.join(current_dir, "static", "svg", "logo.svg")
-    text_path = os.path.join(current_dir, "static", "svg", "text.svg")
-    with open(icon_path, 'r', encoding='utf-8') as icon_file:
-        icon_svg = icon_file.read()
-    with open(text_path, 'r', encoding='utf-8') as text_file:
-        text_svg = text_file.read()
-    return {
-        'icon': icon_svg,
-        'text': text_svg,
-    }
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        return None

orionis/metadata/package.py

@@ -1,158 +1,384 @@
 import requests
 from orionis.metadata.framework import API
 
-class PypiPackageApi:
+class PypiOrionisPackage:
     """
-    PypiPackageApi provides an interface to fetch and access metadata about the Orionis package from PyPI.
-    This class initializes by retrieving package information from the PyPI JSON API for the 'orionis' package.
-    It exposes various methods to access metadata such as the package name, version, author, description, license,
-    classifiers, required Python version, keywords, and project URLs.
+    Provides an interface for retrieving and accessing metadata about the Orionis package from PyPI.
+
+    This class automatically fetches metadata from the PyPI JSON API for the Orionis package upon initialization.
+    The metadata includes information such as package name, version, author, description, license, classifiers,
+    required Python version, keywords, and project URLs. The metadata is stored internally and can be accessed
+    through dedicated methods.
+
+    Attributes
+    ----------
+    _baseUrl : str
+        The base URL for the PyPI API endpoint used to fetch package metadata.
+    _info : dict
+        A dictionary containing the metadata retrieved from the PyPI API.
+
+    Notes
+    -----
+    The metadata is retrieved using the PyPI JSON API and stored in the `_info` attribute.
+    If the request fails or the response structure is invalid, an exception will be raised during initialization.
     """
 
     def __init__(self) -> None:
         """
-        Initializes the class by setting the base URL for the Orionis PyPI package,
-        initializing the information dictionary, and retrieving all package data.
+        Initialize the PypiOrionisPackage instance.
+
+        This constructor sets up the base URL for the Orionis PyPI package, initializes the internal
+        information dictionary, and immediately fetches all available package metadata from PyPI.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It initializes instance attributes and populates
+            the `_info` dictionary with package metadata.
+
+        Notes
+        -----
+        The metadata is retrieved using the PyPI JSON API and stored in the `_info` attribute.
+        If the request fails, an exception will be raised during initialization.
         """
-        self._baseUrl = API
-        self._info = {}
-        self.getAllData()
+        self._baseUrl = API  # Set the base URL for the PyPI API endpoint
+        self._info = {}      # Initialize the dictionary to store package metadata
+        self.getAllData()    # Fetch and populate metadata from PyPI
 
     def getAllData(self) -> dict:
         """
-        Fetches all data from the base URL and updates the internal info attribute.
+        Fetch and update package metadata from the PyPI API.
 
-        Sends a GET request to the specified base URL. If the request is successful (status code 200),
-        parses the JSON response and updates the `_info` attribute with the value associated with the "info" key.
-        Raises an exception if the request fails.
+        This method sends a GET request to the PyPI JSON API endpoint specified by `self._baseUrl`.
+        If the request is successful (HTTP status code 200), it parses the JSON response and updates
+        the internal `_info` attribute with the value associated with the "info" key. If the "info"
+        key is missing or the request fails, an exception is raised.
 
-        Raises:
-            Exception: If the request to the base URL fails or returns a non-200 status code.
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        dict
+            A dictionary containing the package metadata retrieved from PyPI. This dictionary is also
+            stored in the instance's `_info` attribute.
+
+        Raises
+        ------
+        Exception
+            If the request to the PyPI API fails, returns a non-200 status code, or the response
+            structure is invalid (missing the "info" key).
+
+        Notes
+        -----
+        The method uses a timeout of 10 seconds for the HTTP request to avoid hanging indefinitely.
         """
         try:
+            # Send a GET request to the PyPI API endpoint
             response = requests.get(self._baseUrl, timeout=10)
+
+            # Raise an error for non-200 status codes
             response.raise_for_status()
-            data:dict = response.json()
+
+            # Parse the JSON response
+            data: dict = response.json()
+
+            # Extract the 'info' section containing package metadata
             self._info = data.get("info", {})
+
+            # Raise an error if 'info' key is missing or empty
             if not self._info:
                 raise ValueError("No 'info' key found in PyPI response.")
+
+            # Return the package metadata dictionary
             return self._info
+
         except requests.RequestException as e:
+
+            # Handle network or HTTP errors
             raise Exception(
                 f"Error fetching data from PyPI: {e}. "
                 "Please check your internet connection or try again later."
             )
         except ValueError as ve:
+
+            # Handle invalid response structure
             raise Exception(
                 f"Invalid response structure from PyPI: {ve}"
             )
 
     def getName(self) -> str:
         """
-        Returns the package name from the value of the 'name' key in the _info dictionary.
+        Retrieve the package name from the internal metadata dictionary.
 
-        Returns:
-            str: The package name.
+        This method accesses the '_info' attribute, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'name' key. The package name uniquely identifies the
+        Python package as registered on PyPI.
+
+        Returns
+        -------
+        str
+            The name of the package as specified in the PyPI metadata.
+
+        Notes
+        -----
+        The '_info' dictionary must be populated before calling this method, typically during initialization.
+        If the 'name' key is missing, a KeyError will be raised.
         """
+
+        # Return the package name from the metadata dictionary
         return self._info['name']
 
     def getVersion(self) -> str:
         """
-        Returns the version information of the framework.
+        Retrieve the version information of the Orionis framework from the internal metadata dictionary.
 
-        Returns:
-            str: The version string from the framework's information dictionary.
+        This method accesses the '_info' attribute, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'version' key. The version string uniquely identifies
+        the current release of the package as registered on PyPI.
+
+        Returns
+        -------
+        str
+            The version string of the Orionis framework as specified in the PyPI metadata.
+
+        Notes
+        -----
+        The '_info' dictionary must be populated before calling this method, typically during initialization.
+        If the 'version' key is missing, a KeyError will be raised.
         """
+
+        # Return the version string from the metadata dictionary
         return self._info['version']
 
     def getAuthor(self) -> str:
         """
-        Returns the author of the framework.
+        Retrieve the author's name from the internal metadata dictionary.
 
-        Returns:
-            str: The author's name as specified in the framework information.
+        This method accesses the '_info' attribute, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'author' key. The author's name identifies the individual
+        or organization responsible for maintaining the Orionis framework package.
+
+        Returns
+        -------
+        str
+            The author's name as specified in the PyPI metadata. If the 'author' key is missing, a KeyError will be raised.
+
+        Notes
+        -----
+        The '_info' dictionary must be populated before calling this method, typically during initialization.
         """
+
+        # Return the author's name from the metadata dictionary
         return self._info['author']
 
     def getAuthorEmail(self) -> str:
         """
-        Retrieve the author's email address from the internal information dictionary.
+        Retrieve the author's email address from the internal metadata dictionary.
 
-        Returns:
-            str: The email address of the author.
+        This method accesses the '_info' attribute, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'author_email' key. The author's email address is useful
+        for contacting the maintainer of the Orionis framework package.
+
+        Returns
+        -------
+        str
+            The email address of the author as specified in the PyPI metadata. If the 'author_email' key
+            is missing, a KeyError will be raised.
+
+        Notes
+        -----
+        The '_info' dictionary must be populated before calling this method, typically during initialization.
         """
+
+        # Return the author's email address from the metadata dictionary
         return self._info['author_email']
 
     def getDescription(self) -> str:
         """
-        Returns the summary description from the internal information dictionary.
+        Retrieve the summary description of the Orionis framework package.
+
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'summary' key. The summary provides a brief description of the
+        package as registered on PyPI.
 
-        Returns:
-            str: The summary description stored in the '_info' dictionary under the 'summary' key.
+        Returns
+        -------
+        str
+            The summary description of the Orionis framework package, as stored in the '_info' dictionary under the 'summary' key.
+
+        Notes
+        -----
+        The '_info' dictionary must be populated before calling this method, typically during initialization.
+        If the 'summary' key is missing, a KeyError will be raised.
         """
+
+        # Return the summary description from the metadata dictionary
         return self._info['summary']
 
     def getUrl(self) -> str:
         """
-        Retrieves the homepage URL from the project's information.
+        Retrieve the homepage URL of the Orionis framework package from PyPI metadata.
+
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and extracts the homepage URL from the 'project_urls' sub-dictionary under the 'Homepage' key. The homepage
+        URL typically points to the main website or documentation for the Orionis framework.
 
-        Returns:
-            str: The homepage URL specified in the project's 'project_urls' under 'Homepage'.
+        Returns
+        -------
+        str
+            The homepage URL of the Orionis framework package as specified in the PyPI metadata under
+            `_info['project_urls']['Homepage']`.
+
+        Notes
+        -----
+        The `_info` dictionary must be populated before calling this method, typically during initialization.
+        If the 'Homepage' key is missing in the 'project_urls' dictionary, a KeyError will be raised.
         """
+
+        # Access the 'project_urls' dictionary and return the 'Homepage' URL
         return self._info['project_urls']['Homepage']
 
     def getLongDescription(self) -> str:
         """
-        Returns the long description of the framework.
+        Retrieve the long description of the Orionis framework package.
+
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'description' key. The long description typically provides
+        a detailed overview of the package, including features, usage, and other relevant information as
+        registered on PyPI.
 
-        Returns:
-            str: The description text from the framework's information dictionary.
+        Returns
+        -------
+        str
+            The long description text of the Orionis framework package, as stored in the '_info' dictionary
+            under the 'description' key.
+
+        Notes
+        -----
+        The '_info' dictionary must be populated before calling this method, typically during initialization.
+        If the 'description' key is missing, a KeyError will be raised.
         """
+
+        # Return the long description from the metadata dictionary
         return self._info['description']
 
     def getDescriptionContentType(self) -> str:
         """
-        Returns the content type of the description from the internal information dictionary.
+        Retrieve the content type of the package description from the internal metadata dictionary.
+
+        This method accesses the `_info` attribute, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'description_content_type' key. The content type
+        indicates the format of the package's long description, such as 'text/markdown' or 'text/plain'.
 
-        Returns:
-            str: The content type of the description (e.g., 'text/markdown', 'text/plain').
+        Returns
+        -------
+        str
+            The content type of the package description (e.g., 'text/markdown', 'text/plain') as specified
+            in the PyPI metadata under the 'description_content_type' key.
+
+        Notes
+        -----
+        The `_info` dictionary must be populated before calling this method, typically during initialization.
+        If the 'description_content_type' key is missing, a KeyError will be raised.
         """
+
+        # Return the content type of the description from the metadata dictionary
         return self._info['description_content_type']
 
     def getLicense(self) -> str:
         """
-        Returns the license type specified in the framework information.
+        Retrieve the license type specified in the framework metadata.
 
-        If the license information is not set, defaults to "MIT".
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'license' key. If the license information is not set or is an
+        empty string, the method defaults to returning "MIT".
 
-        Returns:
-            str: The license type.
+        Returns
+        -------
+        str
+            The license type as specified in the PyPI metadata under the 'license' key. If the license is not set,
+            returns "MIT".
+
+        Notes
+        -----
+        The `_info` dictionary must be populated before calling this method, typically during initialization.
+        If the 'license' key is missing, a KeyError will be raised.
         """
+
+        # Return the license type from the metadata dictionary, defaulting to "MIT" if not set
         return self._info['license'] or "MIT"
 
     def getClassifiers(self) -> list:
         """
-        Returns the list of classifiers from the internal _info dictionary.
+        Retrieve the list of classifiers associated with the Orionis framework package.
 
-        Returns:
-            list: A list of classifier strings.
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'classifiers' key. Classifiers are standardized strings used
+        by PyPI to categorize the package (e.g., supported Python versions, intended audience, license, etc.).
+
+        Returns
+        -------
+        list of str
+            A list of classifier strings as specified in the PyPI metadata under the 'classifiers' key.
+            Each string describes a category or property of the package.
+
+        Notes
+        -----
+        The `_info` dictionary must be populated before calling this method, typically during initialization.
+        If the 'classifiers' key is missing, a KeyError will be raised.
         """
+
+        # Return the list of classifiers from the metadata dictionary
         return self._info['classifiers']
 
     def getPythonVersion(self) -> str:
         """
-        Retrieves the required Python version for the framework.
+        Retrieve the required Python version specification from the package metadata.
 
-        Returns:
-            str: The Python version specification required by the framework, as defined in the '_info' dictionary.
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'requires_python' key. The returned string specifies the Python
+        version(s) required to use the Orionis framework package, as defined in its PyPI metadata.
+
+        Returns
+        -------
+        str
+            The Python version specification required by the framework, as defined in the '_info' dictionary
+            under the 'requires_python' key. For example, it may return a string like '>=3.7'.
+
+        Notes
+        -----
+        The `_info` dictionary must be populated before calling this method, typically during initialization.
+        If the 'requires_python' key is missing, a KeyError will be raised.
         """
+
+        # Return the required Python version specification from the metadata dictionary
         return self._info['requires_python']
 
     def getKeywords(self) -> list:
         """
-        Retrieve the list of keywords associated with the current object.
+        Retrieve the list of keywords associated with the Orionis framework package.
 
-        Returns:
-            list: A list of keywords from the object's information dictionary.
+        This method accesses the internal `_info` dictionary, which contains metadata fetched from the PyPI API,
+        and returns the value associated with the 'keywords' key. Keywords are typically used to describe the
+        package's functionality, domain, or relevant search terms on PyPI.
+
+        Returns
+        -------
+        list of str
+            A list of keywords describing the Orionis framework package, as specified in the PyPI metadata
+            under the 'keywords' key.
+
+        Notes
+        -----
+        The `_info` dictionary must be populated before calling this method, typically during initialization.
+        If the 'keywords' key is missing, a KeyError will be raised.
         """
+
+        # Return the list of keywords from the metadata dictionary
         return self._info['keywords']