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

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.432.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']

{orionis-0.431.0.dist-info → orionis-0.432.0.dist-info}/METADATA

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

{orionis-0.431.0.dist-info → orionis-0.432.0.dist-info}/RECORD

@@ -5,9 +5,9 @@ orionis/console/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 orionis/console/base/command.py,sha256=2kKyTaEzI16Up-XCUeNeJmDWPLN-CweQm3EgrN9U8NQ,3027
 orionis/console/base/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/base/contracts/command.py,sha256=s9yjma-s1URkVm0EbVvSkETAm-N8xX7OnZS43P8pvk8,1957
-orionis/console/commands/version.py,sha256=6usAWQnhmpCY5S95gRm1xVQc0ph-qd7UwMI_5OaDKmQ,1031
+orionis/console/commands/version.py,sha256=TfiuMCcESdlNuhnbl_h9qbOb8aYDXcc5X1J5LfD1v7M,1041
 orionis/console/contracts/kernel.py,sha256=fzD8FNVSKEQ5gW5D83hVecz9dVHgy28rRDORDdghp4s,409
-orionis/console/core/reactor.py,sha256=MIAMrulZKZalJ8Fz6YiyBVpMD-SQh8-rgrHauVz4kWE,72
+orionis/console/core/reactor.py,sha256=lNfj-L4MKZhBn07l4H5L5dVW2xBRiq6-kyIuqnUNawQ,73
 orionis/console/dumper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/dumper/dump.py,sha256=CATERiQ6XuIrKQsDaWcVxzTtlAJI9qLJX44fQxEX8ws,22443
 orionis/console/dumper/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -140,7 +140,7 @@ orionis/foundation/config/queue/entities/queue.py,sha256=YiWPeEg5e0fd_DJM2ogska6
 orionis/foundation/config/queue/enums/__init__.py,sha256=oWY8GWwr5mex7szs_bLVqAS1jbyuIAvKl7XFGSlU9A0,64
 orionis/foundation/config/queue/enums/strategy.py,sha256=S_kw7KZtoCk5FTOkbuXepdy_fOl9Eav4uT2K0OyzBa0,602
 orionis/foundation/config/roots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/config/roots/paths.py,sha256=kmUsuurIwQrOXZrkcQbXyvaDx2LfyxSHf7R0EsVNTsg,10670
+orionis/foundation/config/roots/paths.py,sha256=YosRpL9R6sSaEkW2PnymTCXSxPQb3-miWoUAC0pVYvw,10676
 orionis/foundation/config/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/session/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/session/entities/session.py,sha256=sJoD-_CiwUR88tva-rO22bagG3RTcHXrQGWbq4B5joM,5998
@@ -172,8 +172,8 @@ orionis/foundation/providers/progress_bar_provider.py,sha256=WW3grNgH-yV2meSSTeO
 orionis/foundation/providers/testing_provider.py,sha256=iJSN2RIChbYIL-1ue6vmPmDMCSrvERDkti4Er9MPiLA,1102
 orionis/foundation/providers/workers_provider.py,sha256=kiQjQRyUEyiBX2zcbF_KmqRgvc7Bvxsvg5oMtIvYniM,1075
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=jUpRhT0gwyJCTGRjokcPsJ_5xAzwPm8DiXbkVCPLTTs,4960
-orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
+orionis/metadata/framework.py,sha256=LBzTF3hSKCydEkAyPmHP7iDOK7OLk0C-XU4u8cpSnvU,4088
+orionis/metadata/package.py,sha256=k7Yriyp5aUcR-iR8SK2ec_lf0_Cyc-C7JczgXa-I67w,16039
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/coroutines.py,sha256=Aj5a1LTosnGUA0meSHivC1OJBYOQ7xq3US_PzWTc91w,3113
@@ -340,7 +340,7 @@ orionis/test/validators/web_report.py,sha256=-h3Fe9jY93_kzUhd2NBIqEfCcBpu-8Ei9x3
 orionis/test/validators/workers.py,sha256=LGffDKtK6SKixFKzIYPQpI5aFeQPAGXpv_LUtmEu6g4,1102
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=3ICz68l-WF3BtnYqH5m-ktN9UD00MELMbmMnyJDV74A,4768
-orionis-0.431.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.432.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/test_container.py,sha256=asv8TkkupVoex6SWod74NBl4dSs7wb9mLmu_glNdNy8,14815
@@ -426,8 +426,8 @@ tests/foundation/config/startup/test_foundation_config_startup.py,sha256=9ZFwbWx
 tests/foundation/config/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/foundation/config/testing/test_foundation_config_testing.py,sha256=YsXTVxq-S1KVlLK5fe2qL0CpQrulaLmy6sMSm3oPhbA,8237
 tests/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/metadata/test_metadata_framework.py,sha256=1tCNciuPVgZPK-V8PzENJCXN-1bTktWPN9u03N4Eelw,5499
-tests/metadata/test_metadata_package.py,sha256=gXIX-N9toEHJsmFkdhAvJRnz2T5e6pbgK37I1eFYTGM,4770
+tests/metadata/test_metadata_framework.py,sha256=vOsp5owDMMoL5dtgiN9EC5Sdj8pemXVh62MzYpPUK4Q,5327
+tests/metadata/test_metadata_package.py,sha256=AcD5rlkD5MeX2tJvQkIHeGeAl88k0tsF2wOU5v4JVN0,4894
 tests/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/asynchrony/test_services_asynchrony_coroutine.py,sha256=34Y0D6w2bVo_dm3oj0wzedMIJuSYieUG9Y2J1EQmZeo,3439
@@ -485,8 +485,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=QdcF0Vhnnl_kD-PzceHJbUYOqwPTB1Td7YaTv8LTr30,19612
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=-ghGG8rimyb2b2wtvMuSPPH7Zac5_NlVCiUcHRA5SNg,1172
-orionis-0.431.0.dist-info/METADATA,sha256=N5ix3L6pXjR5vmSl7I9rPjmmV98VTGw5XQ7gjHAHN1Y,4772
-orionis-0.431.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.431.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.431.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.431.0.dist-info/RECORD,,
+orionis-0.432.0.dist-info/METADATA,sha256=UefeivB8kYskWoBDWmFfmDaWFDLVsR8fSGrbmjDtpUc,4772
+orionis-0.432.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.432.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.432.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.432.0.dist-info/RECORD,,

tests/metadata/test_metadata_framework.py

@@ -4,163 +4,137 @@ from orionis.test.cases.asynchronous import AsyncTestCase
 class TestMetadataFramework(AsyncTestCase):
     """
     Test cases for the metadata constants and utility functions in orionis.metadata.framework.
-
-    Notes
-    -----
-    This test suite validates the existence, type, and structure of metadata constants and utility
-    functions provided by the `orionis.metadata.framework` module.
     """
 
     async def testConstantsExistAndAreStr(self):
         """
-        Validate that all metadata constants exist and are of type `str`.
-
-        This test iterates over a predefined list of metadata constants and checks
-        that each constant is present and its type is `str`.
+        Test that all required metadata constants exist and are of type `str`.
 
-        Raises
-        ------
-        AssertionError
-            If any constant is not a string.
+        This method iterates over a predefined list of metadata constants and checks
+        that each is an instance of `str`. This ensures that the metadata values
+        required by the framework are properly defined and typed.
 
         Returns
         -------
         None
-            This method does not return any value.
+            This is a test method and does not return any value. Assertions are used
+            to validate the conditions.
         """
 
-        # Check each metadata constant for type str
+        # List of metadata constants to check
         for const in [
             NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
             SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
         ]:
+            # Assert that each constant is a string
             self.assertIsInstance(const, str)
 
     async def testClassifiersStructure(self):
         """
-        Ensure that `CLASSIFIERS` is a list of tuples containing strings.
+        Validate the structure and type of the `CLASSIFIERS` metadata constant.
 
-        This test verifies the structure of the `CLASSIFIERS` constant, ensuring
-        it is a list where each element is a tuple, and each tuple contains only strings.
+        This test ensures that the `CLASSIFIERS` constant is a list of strings,
+        and that each string contains at least one '::' separator, which is
+        typical for Python package classifiers.
 
-        Raises
-        ------
-        AssertionError
-            If `CLASSIFIERS` is not a list of tuples of strings.
+        Parameters
+        ----------
+        self : TestMetadataFramework
+            The test case instance.
 
         Returns
         -------
         None
-            This method does not return any value.
+            This method does not return any value. Assertions are used to
+            validate the structure and contents of `CLASSIFIERS`.
         """
 
-        # Confirm CLASSIFIERS is a list
+        # Assert that CLASSIFIERS is a list
         self.assertIsInstance(CLASSIFIERS, list)
-
-        # Check each item in CLASSIFIERS for tuple of strings
         for item in CLASSIFIERS:
-            self.assertIsInstance(item, tuple)
-            self.assertTrue(all(isinstance(part, str) for part in item))
-
-    async def testGetClassifiers(self):
-        """
-        Verify that `get_classifiers` returns a list of classifier strings.
-
-        This test calls the `get_classifiers` utility function and checks that
-        the returned value is a list of strings, each representing a classifier.
-
-        Raises
-        ------
-        AssertionError
-            If the returned value is not a list of strings containing '::'.
 
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
+            # Assert that each item in CLASSIFIERS is a string
+            self.assertIsInstance(item, str)
 
-        # Retrieve classifiers and validate their format
-        classifiers = get_classifiers()
-        self.assertIsInstance(classifiers, list)
-        for c in classifiers:
-            self.assertIsInstance(c, str)
-            self.assertTrue(" :: " in c or len(c.split(" :: ")) > 1)
+            # Assert that each classifier string contains at least one '::' separator
+            self.assertTrue("::" in item or len(item.split("::")) > 1)
 
     async def testKeywords(self):
         """
-        Check that `KEYWORDS` is a list of strings and contains required keywords.
+        Validate the structure and contents of the `KEYWORDS` metadata constant.
 
-        This test ensures that the `KEYWORDS` constant is a list of strings and
-        verifies the presence of specific keywords relevant to the framework.
+        This test checks that the `KEYWORDS` constant is a list of strings, ensuring
+        that each keyword is properly typed. Additionally, it verifies that the list
+        contains the essential keywords "orionis" and "framework", which are required
+        for accurate metadata representation.
 
-        Raises
-        ------
-        AssertionError
-            If `KEYWORDS` is not a list of strings or required keywords are missing.
+        Parameters
+        ----------
+        self : TestMetadataFramework
+            The test case instance.
 
         Returns
         -------
         None
-            This method does not return any value.
+            This method does not return any value. Assertions are used to validate
+            the structure and contents of `KEYWORDS`.
         """
 
-        # Confirm KEYWORDS is a list of strings
+        # Assert that KEYWORDS is a list
         self.assertIsInstance(KEYWORDS, list)
+
+        # Check that each keyword in KEYWORDS is a string
         for kw in KEYWORDS:
             self.assertIsInstance(kw, str)
 
-        # Check for required keywords
+        # Ensure essential keywords are present in the list
         self.assertIn("orionis", KEYWORDS)
         self.assertIn("framework", KEYWORDS)
 
     async def testRequiresStructure(self):
         """
-        Validate that `REQUIRES` is a list of 2-element tuples of strings.
+        Validate the structure and contents of the `REQUIRES` metadata constant.
 
-        This test checks the structure of the `REQUIRES` constant, ensuring it is
-        a list where each element is a tuple of length 2, and both elements are strings.
+        This test checks that the `REQUIRES` constant is a list of strings, where each string
+        represents a package requirement and contains the '>=' version specifier. This ensures
+        that all requirements are properly typed and formatted for dependency management.
 
-        Raises
-        ------
-        AssertionError
-            If `REQUIRES` is not a list of 2-element tuples of strings.
+        Parameters
+        ----------
+        self : TestMetadataFramework
+            The test case instance.
 
         Returns
         -------
         None
-            This method does not return any value.
+            This method does not return any value. Assertions are used to validate
+            the structure and contents of `REQUIRES`.
         """
 
-        # Confirm REQUIRES is a list of 2-element tuples of strings
+        # Assert that REQUIRES is a list
         self.assertIsInstance(REQUIRES, list)
+
+        # Check that each requirement in REQUIRES is a string and contains '>='
         for req in REQUIRES:
-            self.assertIsInstance(req, tuple)
-            self.assertEqual(len(req), 2)
-            self.assertTrue(all(isinstance(part, str) for part in req))
+            self.assertIsInstance(req, str)  # Each requirement should be a string
+            self.assertIn(">=", req)         # Each requirement should specify a minimum version
 
-    async def testGetRequires(self):
+    async def testIconFunction(self):
         """
-        Ensure that `get_requires` returns a list of requirement strings.
-
-        This test calls the `get_requires` utility function and checks that the
-        returned value is a list of strings, each representing a requirement and
-        containing the '>=' version specifier.
+        Test the behavior and return type of the `icon()` utility function.
 
-        Raises
-        ------
-        AssertionError
-            If the returned value is not a list of strings containing '>='.
+        This test verifies that the `icon()` function returns either a string containing
+        SVG data or `None` if the icon file is not found. It ensures that the function's
+        output is correctly typed and handles missing resources gracefully.
 
         Returns
         -------
         None
-            This method does not return any value.
+            This method does not return any value. Assertions are used to validate
+            the type and behavior of the `icon()` function.
         """
+        # Call the icon() function and store the result
+        result = icon()
 
-        # Retrieve requirements and validate their format
-        requires = get_requires()
-        self.assertIsInstance(requires, list)
-        for req in requires:
-            self.assertIsInstance(req, str)
-            self.assertIn(">=", req)
+        # Assert that the result is either a string (SVG data) or None (file not found)
+        self.assertTrue(isinstance(result, str) or result is None)

tests/metadata/test_metadata_package.py

@@ -1,19 +1,19 @@
 from orionis.test.cases.asynchronous import AsyncTestCase
 from unittest.mock import patch
 
-class TestPypiPackageApi(AsyncTestCase):
+class TestPypiOrionisPackage(AsyncTestCase):
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetName(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetName(self, MockPypiOrionisPackage):
         """
-        Tests the `getName` method of the `PypiPackageApi` class.
+        Tests the `getName` method of the `PypiOrionisPackage` class.
 
         This test verifies that the mocked `getName` method returns the expected package name.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -22,7 +22,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getName
         api.getName.return_value = "orionis"
@@ -30,17 +30,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getName returns the expected value
         self.assertEqual(api.getName(), "orionis")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetAuthor(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetAuthor(self, MockPypiOrionisPackage):
         """
-        Tests the `getAuthor` method of the `PypiPackageApi` class.
+        Tests the `getAuthor` method of the `PypiOrionisPackage` class.
 
         This test checks that the mocked `getAuthor` method returns the correct author name.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -49,7 +49,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getAuthor
         api.getAuthor.return_value = "Raul Mauricio Uñate Castro"
@@ -57,17 +57,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getAuthor returns the expected value
         self.assertEqual(api.getAuthor(), "Raul Mauricio Uñate Castro")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetAuthorEmail(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetAuthorEmail(self, MockPypiOrionisPackage):
         """
-        Tests the `getAuthorEmail` method of the `PypiPackageApi` class.
+        Tests the `getAuthorEmail` method of the `PypiOrionisPackage` class.
 
         This test ensures that the mocked `getAuthorEmail` method returns the correct author email address.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -76,7 +76,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getAuthorEmail
         api.getAuthorEmail.return_value = "raulmauriciounate@gmail.com"
@@ -84,17 +84,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getAuthorEmail returns the expected value
         self.assertEqual(api.getAuthorEmail(), "raulmauriciounate@gmail.com")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetDescription(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetDescription(self, MockPypiOrionisPackage):
         """
-        Tests the `getDescription` method of the `PypiPackageApi` class.
+        Tests the `getDescription` method of the `PypiOrionisPackage` class.
 
         This test verifies that the mocked `getDescription` method returns the expected package description.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -103,7 +103,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getDescription
         api.getDescription.return_value = "Orionis Framework – Elegant, Fast, and Powerful."
@@ -111,17 +111,17 @@ class TestPypiPackageApi(AsyncTestCase):
         # Assert that getDescription returns the expected value
         self.assertEqual(api.getDescription(), "Orionis Framework – Elegant, Fast, and Powerful.")
 
-    @patch("orionis.metadata.package.PypiPackageApi")
-    async def testGetPythonVersion(self, MockPypiPackageApi):
+    @patch("orionis.metadata.package.PypiOrionisPackage")
+    async def testGetPythonVersion(self, MockPypiOrionisPackage):
         """
-        Tests the `getPythonVersion` method of the `PypiPackageApi` class.
+        Tests the `getPythonVersion` method of the `PypiOrionisPackage` class.
 
         This test checks that the mocked `getPythonVersion` method returns the correct Python version requirement.
 
         Parameters
         ----------
-        MockPypiPackageApi : MagicMock
-            Mocked `PypiPackageApi` class.
+        MockPypiOrionisPackage : MagicMock
+            Mocked `PypiOrionisPackage` class.
 
         Returns
         -------
@@ -130,7 +130,7 @@ class TestPypiPackageApi(AsyncTestCase):
         """
 
         # Get the mocked API instance
-        api = MockPypiPackageApi.return_value
+        api = MockPypiOrionisPackage.return_value
 
         # Set the return value for getPythonVersion
         api.getPythonVersion.return_value = ">=3.12"