orionis 0.444.0__py3-none-any.whl → 0.445.0__py3-none-any.whl

orionis/foundation/application.py

@@ -174,7 +174,6 @@ class Application(Container, IApplication):
         # Import core framework providers
         from orionis.foundation.providers.console_provider import ConsoleProvider
         from orionis.foundation.providers.dumper_provider import DumperProvider
-        from orionis.foundation.providers.path_resolver_provider import PathResolverProvider
         from orionis.foundation.providers.progress_bar_provider import ProgressBarProvider
         from orionis.foundation.providers.workers_provider import WorkersProvider
         from orionis.foundation.providers.testing_provider import TestingProvider
@@ -183,7 +182,6 @@ class Application(Container, IApplication):
         core_providers = [
             ConsoleProvider,
             DumperProvider,
-            PathResolverProvider,
             ProgressBarProvider,
             WorkersProvider,
             LoggerProvider,

orionis/metadata/framework.py

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

{orionis-0.444.0.dist-info → orionis-0.445.0.dist-info}/METADATA

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

{orionis-0.444.0.dist-info → orionis-0.445.0.dist-info}/RECORD

@@ -68,7 +68,7 @@ orionis/container/validators/is_subclass.py,sha256=4sBaGLoRs8nUhuWjlP0VJqyTwVHYq
 orionis/container/validators/is_valid_alias.py,sha256=4uAYcq8xov7jZbXnpKpjNkxcZtlTNnL5RRctVPMwJes,1424
 orionis/container/validators/lifetime.py,sha256=IQ43fDNrxYHMlZH2zlYDJnlkLO_eS4U7Fs3UJgQBidI,1844
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/application.py,sha256=w_7ZNdcrL4u9a0eqQOAMiLxbnfB7ydNGFgh6xNnCVYA,76782
+orionis/foundation/application.py,sha256=ErkfS6AlC817vBmVDbx_UVYmkaABuEqZCBCrkDGNmzo,76653
 orionis/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/startup.py,sha256=vbzduprRCNyYeR2nnMaqc1uKXw6PTzAY2jVfXNQKN8I,9691
 orionis/foundation/config/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -174,12 +174,11 @@ orionis/foundation/providers/console_provider.py,sha256=wsv0RjoYU9MatC1ZRBAtV9iC
 orionis/foundation/providers/dumper_provider.py,sha256=d0k9yKVfwf40W4If0_rF09odLDXFA1w9jxU1MvZvCbo,1498
 orionis/foundation/providers/inspirational_provider.py,sha256=ZIsuEq2Sif7C1b1hYC7_mEBd0kGwd8KWd-fHyyd6Qs4,2298
 orionis/foundation/providers/logger_provider.py,sha256=PvwMxP5TKmn9DP8H8nJfyr16XgiJaGHyxPSMOpFgv84,1448
-orionis/foundation/providers/path_resolver_provider.py,sha256=s44Mg68RsUNPlilQlXMBE7onVexa7kyDmVQmci1JL4g,1342
 orionis/foundation/providers/progress_bar_provider.py,sha256=P__zpCyC29WCwErYGbh5dgcMRxw3XYmHzaUkzms9vPM,1345
 orionis/foundation/providers/testing_provider.py,sha256=fSZfwKnScTxGlGrcEPReGIiOPs8XkoEaNNARN1wC6LU,2939
 orionis/foundation/providers/workers_provider.py,sha256=YMRLdq_YQnR1unnoYvDpYQZbLli04f0CckuR6Q--wKg,1379
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=Que9Q_spu-gld9CNZt90yTGnUPDQBWf87yrjBiveqPQ,4088
+orionis/metadata/framework.py,sha256=192rDsW-nKtJVGcJdvakEiGySD3zpYemH8-LYFk5spQ,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
@@ -260,13 +259,6 @@ orionis/services/log/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 orionis/services/log/handlers/filename.py,sha256=XKkq4Gq7N2m8F3xtyUIevTQLMaYSLJ3wC04Irs45VcE,2481
 orionis/services/log/handlers/size_rotating.py,sha256=SLg7r-XW1NWyVxN8wJxeI8jhypzdXw_jq2zg5uy3iaQ,1131
 orionis/services/log/handlers/timed_rotating.py,sha256=UJicPwHcIVl2FPRPjuiKwH3-zuiPG1YV7UYLLMPm4To,1128
-orionis/services/paths/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/paths/resolver.py,sha256=6XPQ4D2P-8teg_lJAC4Ju_bAxbkb5rjoR3D-CaNmYAQ,3097
-orionis/services/paths/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/paths/contracts/resolver.py,sha256=3RFi2mlwqSwknYvZCnyKVcTIUEhb7k21oTs9gSP3m3U,1144
-orionis/services/paths/exceptions/__init__.py,sha256=r5b4D4XWNK07zLtqaXBk_PNYszScqbp_8kUN37cOk4E,184
-orionis/services/paths/exceptions/exception.py,sha256=cK-TbUT02X2lvbAP4yFdfHx4S45wBOcYl3_tiWd67UM,472
-orionis/services/paths/exceptions/file.py,sha256=bsK0QoXwRFyDeHvITxwmgaBuwiO2eoRUhRzNizmX1No,475
 orionis/services/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/system/imports.py,sha256=aSXG9879ur91d6OsqV2DUYWmmwbwFHX8CHb99cPfFcU,7057
 orionis/services/system/workers.py,sha256=EfGxU_w42xRnZ1yslsui3wVG8pfe__V3GYGEIyo8JxQ,3144
@@ -283,7 +275,6 @@ orionis/support/facades/console.py,sha256=OvxQ-r8PsPocJTaIUftmJnnr4SuONHQWYFz2_r
 orionis/support/facades/dumper.py,sha256=XAHJTXrMjPchGQMIAU0hlcUjMZQK_ogrE0voRm2HdI8,434
 orionis/support/facades/inspire.py,sha256=m2UbKXyggxASd0HTRT5M-mJ0FvMP_NIJ0lW8HTQMi4M,759
 orionis/support/facades/logger.py,sha256=2EbSbJDSyKFUQmZUpoMsc5704Mzj2Skehx_9UpDluhc,450
-orionis/support/facades/path_resolver.py,sha256=lRLbu69i8PzM-I53gzXroHIurxzyFdssNWOYMjPgqco,442
 orionis/support/facades/progress_bar.py,sha256=NOCwAV873GptedgySMZpM_A_DoM-UQrMg2kDHpS6zi8,423
 orionis/support/facades/testing.py,sha256=FJy7bnDiNHMe7jutARELHom6umDxlLVMMOj6aLm0Vak,490
 orionis/support/facades/workers.py,sha256=DJ_mSnD4budFBrPGf-epVYrSQ1AzDcJ82db0QmNTAyU,479
@@ -352,7 +343,7 @@ orionis/test/validators/web_report.py,sha256=n9BfzOZz6aEiNTypXcwuWbFRG0OdHNSmCNu
 orionis/test/validators/workers.py,sha256=rWcdRexINNEmGaO7mnc1MKUxkHKxrTsVuHgbnIfJYgc,1206
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=f-zNhtKSg9R5Njqujbg2l2amAs2-mRVESneLIkWOZjU,4082
-orionis-0.444.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.445.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -386,7 +377,7 @@ tests/container/validators/test_is_subclass.py,sha256=0Uc8uIR69ZX7G5Nrex0LMQXrue
 tests/container/validators/test_is_valid_alias.py,sha256=NA9QbIEh7n2_0GeVTMCppZG4_3ya4QrcvGI_lw1iJA8,5658
 tests/container/validators/test_lifetime.py,sha256=5PequjXAcIcp0Q4TIki7THSU31XftGpI0u1mVGqHmpU,4692
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/example/test_example.py,sha256=XJEcsro3vCO5m4zvMiWUGphvd0C7oIkBtUfQgTDsdUU,25568
+tests/example/test_example.py,sha256=W6lA0_uV6bNm7JZ39rHZn30LHkdq_ddrUO6T1K2raZ4,27104
 tests/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/foundation/config/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -464,8 +455,6 @@ tests/services/introspection/reflection/mock/__init__.py,sha256=47DEQpj8HBSa-_TI
 tests/services/introspection/reflection/mock/fake_reflect_instance.py,sha256=iMf_yKgk0Y91XUHhRcl2qw7Z83QeNspvLi_tl4Dp-rI,28032
 tests/services/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/log/test_log.py,sha256=fCI2gX9-YN1z-xPMwIlggUFHeBlqfUajQoyQu4dmao0,2868
-tests/services/path/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/path/test_services_resolver.py,sha256=aWSSFgV_D10t3llUeCWEBB1mF3dWrZbFn5XbJy2sQME,3903
 tests/services/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/system/test_services_system_imports.py,sha256=jbtIQkw_4DI6x2E-4Lg3evnLAgCgDIBWE63LdJTLkxc,7507
 tests/services/system/test_services_system_workers.py,sha256=wITbpJHKW_OXqTaFeteNRFuw5Q3_7d9lWNJnFE2r6to,5052
@@ -498,8 +487,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=WPo5GxTP6xE-Dw3X1vZoqOMpb6HhokjNSbgDsDRDvy4,16588
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=tnnMBwS0iKUIbogLvu-7Rii50G6Koddp3XT4wgdFEYM,1050
-orionis-0.444.0.dist-info/METADATA,sha256=YgxccCDNizNHssu-14sVeL6dVMvkTMfvdfd3UcB1SeY,4772
-orionis-0.444.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.444.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.444.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.444.0.dist-info/RECORD,,
+orionis-0.445.0.dist-info/METADATA,sha256=7gz5KAzfzBJKnWCXoyTfW7Izx8pbJGm9SR-LDA3F4rQ,4772
+orionis-0.445.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.445.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.445.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.445.0.dist-info/RECORD,,

tests/example/test_example.py

@@ -1,42 +1,8 @@
-"""
-Orionis Framework Test Examples
-===============================
-
-This module contains comprehensive test examples demonstrating the capabilities
-of the Orionis testing framework, including both synchronous and asynchronous
-testing patterns with dependency injection.
-
-Examples:
---------
-    Run synchronous tests:
-        >>> from tests.example.test_example import TestSynchronousExample
-        >>> test = TestSynchronousExample()
-        >>> test.setUp()
-        >>> test.testBasicAssertions()
-
-    Run asynchronous tests:
-        >>> from tests.example.test_example import TestAsynchronousExample
-        >>> test = TestAsynchronousExample()
-        >>> await test.asyncSetUp()
-        >>> await test.testAsyncBasicOperations()
-
-Notes:
------
-    These examples showcase:
-    - Dependency injection patterns
-    - Path resolution services
-    - Container integration
-    - Error handling strategies
-    - Data validation techniques
-    - Concurrent operations
-    - Async/await patterns
-"""
-
 import asyncio
 import time
 from typing import Dict, List, Any
 from orionis.foundation.application import Application
-from orionis.services.paths.contracts.resolver import IResolver
+from orionis.services.system.contracts.workers import IWorkers
 from orionis.test.cases.asynchronous import AsyncTestCase
 from orionis.test.cases.synchronous import SyncTestCase
 
@@ -48,44 +14,6 @@ class TestSynchronousExample(SyncTestCase):
     path resolution, container usage, and error handling in a synchronous context.
     The tests demonstrate best practices for writing maintainable and reliable
     test cases within the Orionis framework.
-
-    Attributes
-    ----------
-    test_data : Dict[str, Any]
-        Test data dictionary containing sample files and expected values
-        for use across multiple test methods.
-
-    Methods
-    -------
-    setUp()
-        Initialize test environment before each test method execution.
-    tearDown()
-        Clean up resources after each test method completion.
-    testBasicAssertions()
-        Validate basic assertion functionality and patterns.
-    testPathResolution(paths)
-        Test path resolution service functionality with dependency injection.
-    testContainerIntegration(container)
-        Validate container dependency injection capabilities.
-    testErrorHandling()
-        Test error handling and exception management patterns.
-    testDataValidation()
-        Validate data validation and complex assertion patterns.
-
-    Examples
-    --------
-    Basic usage:
-        >>> test = TestSynchronousExample()
-        >>> test.setUp()
-        >>> test.testBasicAssertions()
-        >>> test.tearDown()
-
-    With dependency injection:
-        >>> test = TestSynchronousExample()
-        >>> test.setUp()
-        >>> # Path resolver will be injected automatically
-        >>> test.testPathResolution(resolver_instance)
-        >>> test.tearDown()
     """
 
     def setUp(self) -> None:
@@ -156,90 +84,112 @@ class TestSynchronousExample(SyncTestCase):
             "Unexpected value found in container"
         )
 
-    def testPathResolution(self, paths: IResolver) -> None:
+    def testMaxWorkers(self, worker: IWorkers) -> None:
         """
-        Test path resolution service functionality with dependency injection.
+        Test worker service functionality with dependency injection.
 
-        Validates the path resolution service by testing relative path creation
-        and string conversion operations. This method demonstrates how dependency
-        injection works within the Orionis testing framework.
+        Validates the worker service's ability to calculate the maximum number
+        of available workers in the system. This method demonstrates dependency
+        injection capabilities with the IWorkers service and ensures proper
+        worker count calculation functionality.
 
         Parameters
         ----------
-        paths : IResolver
-            Injected path resolver service instance for testing path operations.
-            This parameter is automatically injected by the testing framework
-            based on the type annotation.
+        worker : IWorkers
+            Injected worker service instance for testing worker calculation
+            capabilities. The service provides methods for determining optimal
+            worker counts based on system resources.
+
+        Returns
+        -------
+        None
+            This test method does not return any value. It performs assertions
+            to validate the worker service functionality.
 
         Tests
         -----
-        - Relative path creation from string path
-        - Path string conversion and format validation
-        - Path ending validation
-        - Path content validation
+        - Worker service instance validation
+        - Worker count calculation functionality
+        - Worker count positive value validation
+        - Service method execution through dependency injection
 
         Raises
         ------
         AssertionError
-            If path resolution fails or returns unexpected results.
+            If worker count calculation fails, returns invalid values, or
+            the calculated worker count is not greater than zero.
         """
-        # Test relative path resolution
-        relative_path = paths.relativePath(self.test_data["sample_file"])
-        path_string = relative_path.toString()
 
-        # Verify path resolution results
-        self.assertTrue(
-            path_string.endswith("test_example.py"),
-            "Path should end with test_example.py"
-        )
-        self.assertIn(
-            "test_example.py",
-            path_string,
-            "Path should contain expected directory structure"
+        # Calculate maximum available workers using the injected service
+        max_workers = worker.calculate()
+
+        # Validate that worker count is greater than zero
+        self.assertGreater(
+            max_workers,
+            0,
+            "Worker count should be greater than zero"
         )
 
     def testContainerIntegration(self, container: Application) -> None:
         """
         Test container dependency injection functionality.
 
-        Validates the container's ability to resolve services and manage
-        dependencies. This method demonstrates the dependency injection
-        capabilities of the Orionis application container.
+        Validates the application container's ability to resolve services and manage
+        dependencies correctly. This method demonstrates the dependency injection
+        capabilities of the Orionis application container, including service
+        registration, resolution, and lifecycle management. The test ensures that
+        the container can successfully instantiate and provide service instances
+        when requested through the dependency injection mechanism.
 
         Parameters
         ----------
         container : Application
             Injected application container instance for testing dependency
-            injection capabilities. The container manages service resolution
-            and dependency lifecycle.
+            injection capabilities. The container manages service resolution,
+            dependency lifecycle, and provides access to registered services
+            throughout the application.
+
+        Returns
+        -------
+        None
+            This test method does not return any value. It performs assertions
+            to validate the container's dependency injection functionality.
 
         Tests
         -----
-        - Container instance validation
-        - Service resolution from container
-        - Service functionality validation through container
-        - Dependency lifecycle management
+        - Container instance validation and null checking
+        - Service resolution from container using interface contracts
+        - Service functionality validation through container-resolved instances
+        - Dependency lifecycle management and proper instantiation
+        - Interface-to-implementation mapping verification
 
         Raises
         ------
         AssertionError
-            If container operations fail or services cannot be resolved.
+            If container operations fail, services cannot be resolved, or
+            the container instance is invalid or None.
+
+        Notes
+        -----
+        This test validates the core dependency injection functionality that
+        is essential for the Orionis framework's service architecture. The
+        container must be able to resolve services using their interface
+        contracts and provide properly configured instances.
         """
-        # Test container instance validation
+
+        # Validate that the injected container instance is not None
+        # This ensures the dependency injection framework is working correctly
         self.assertIsNotNone(container, "Container instance should not be None")
 
-        # Test service resolution from container
-        path_resolver: IResolver = container.make(IResolver)
-        self.assertIsNotNone(
-            path_resolver,
-            "Service resolution should return valid instance"
-        )
+        # Attempt to resolve the IWorkers service from the container
+        # This tests the container's ability to map interfaces to implementations
+        workers: IWorkers = container.make(IWorkers)
 
-        # Test service functionality through container
-        test_path = path_resolver.relativePath("README.md")
+        # Verify that the service resolution was successful
+        # The container should return a valid instance implementing IWorkers
         self.assertIsNotNone(
-            test_path,
-            "Service method execution should return valid result"
+            workers,
+            "Service resolution should return valid instance"
         )
 
     def testErrorHandling(self) -> None:
@@ -436,54 +386,50 @@ class TestAsynchronousExample(AsyncTestCase):
             "Async sleep duration should not exceed maximum time tolerance"
         )
 
-    async def testAsyncPathResolution(self, paths: IResolver) -> None:
+    async def testAsyncMaxWorkers(self, worker: IWorkers) -> None:
         """
-        Test async path resolution service functionality with dependency injection.
+        Test async worker service functionality with dependency injection.
 
-        Validates async path resolution operations by simulating async I/O
-        operations and testing path resolution in an asynchronous context.
+        Validates async worker operations by simulating async I/O
+        operations and testing worker calculation in an asynchronous context.
         This method demonstrates async dependency injection patterns.
 
         Parameters
         ----------
-        paths : IResolver
-            Injected path resolver service instance for async path operations.
+        worker : IWorkers
+            Injected worker service instance for async worker operations.
             This parameter is automatically injected by the async testing framework.
 
         Tests
         -----
-        - Async path resolution with simulated I/O delay
-        - Path string conversion in async context
-        - Path validation in async operations
+        - Async worker calculation with simulated I/O delay
+        - Worker count validation in async context
+        - Worker validation in async operations
         - Async service method execution
 
         Raises
         ------
         AssertionError
-            If async path resolution fails or returns unexpected results.
+            If async worker calculation fails or returns unexpected results.
         """
-        async def resolve_path_async(path_name: str) -> str:
+        async def calculate_workers_async() -> int:
             """
-            Simulate async path resolution with I/O delay.
-
-            Parameters
-            ----------
-            path_name : str
-                Path name to resolve asynchronously.
+            Simulate async worker calculation with I/O delay.
 
             Returns
             -------
-            str
-                Resolved path as string.
+            int
+                Calculated maximum workers count.
             """
             await asyncio.sleep(0.01)  # Simulate async I/O operation
-            return paths.relativePath(path_name).toString()
-
-        # Test async path resolution
-        resolved_path = await resolve_path_async("tests/example/test_example.py")
-        self.assertTrue(
-            resolved_path.endswith("test_example.py"),
-            "Async path resolution should return correct file ending"
+            return worker.calculate()
+
+        # Test async worker calculation
+        max_workers = await calculate_workers_async()
+        self.assertGreater(
+            max_workers,
+            0,
+            "Async worker calculation should return positive value"
         )
 
     async def testConcurrentOperations(self) -> None:
@@ -602,64 +548,108 @@ class TestAsynchronousExample(AsyncTestCase):
         """
         Test async container dependency injection functionality.
 
-        Validates the container's ability to resolve services in async
-        contexts and manage async dependencies. This method demonstrates
-        async dependency injection patterns and service resolution.
+        Validates the application container's ability to resolve services and manage
+        dependencies in asynchronous contexts. This method demonstrates async dependency
+        injection patterns, service resolution capabilities, and validates that the
+        container can properly handle service lifecycle management in async environments.
+        The test ensures that services resolved through the container maintain their
+        functionality when used in asynchronous operations.
 
         Parameters
         ----------
         container : Application
-            Injected application container instance for testing async
-            dependency injection capabilities.
+            Injected application container instance for testing async dependency
+            injection capabilities. The container manages service resolution,
+            dependency lifecycle, and provides access to registered services
+            throughout the async application context.
+
+        Returns
+        -------
+        None
+            This test method does not return any value. It performs assertions
+            to validate the container's async dependency injection functionality
+            and service resolution capabilities in asynchronous contexts.
 
         Tests
         -----
-        - Async service resolution from container
-        - Async service method execution
-        - Async dependency lifecycle management
-        - Async service functionality validation
+        - Async service resolution from container using interface contracts
+        - Service instance validation after async resolution
+        - Async service method execution and functionality verification
+        - Dependency lifecycle management in async contexts
+        - Interface-to-implementation mapping in async scenarios
 
         Raises
         ------
         AssertionError
-            If async container operations fail or services cannot be resolved.
+            If async container operations fail, services cannot be resolved,
+            service methods return invalid results, or the container instance
+            fails to properly manage async dependencies.
+
+        Notes
+        -----
+        This test validates the core async dependency injection functionality
+        that is essential for the Orionis framework's async service architecture.
+        The container must be able to resolve services using their interface
+        contracts and provide properly configured instances that work correctly
+        in asynchronous execution contexts.
         """
-        async def resolve_service_async() -> IResolver:
+        async def resolve_service_async() -> IWorkers:
             """
-            Simulate async service resolution.
+            Simulate async service resolution with I/O delay.
+
+            Demonstrates async service resolution from the container while
+            simulating real-world async I/O operations that might occur
+            during service instantiation or configuration.
 
             Returns
             -------
-            IResolver
-                Resolved path resolver service instance.
+            IWorkers
+                Resolved worker service instance implementing the IWorkers interface.
             """
+            # Simulate async I/O operation that might occur during service resolution
             await asyncio.sleep(0.01)
-            return container.make(IResolver)
+            # Resolve the IWorkers service from the injected container
+            return container.make(IWorkers)
 
-        # Test async service resolution
-        path_resolver = await resolve_service_async()
+        # Test async service resolution from the container
+        # This validates that the container can resolve services in async contexts
+        worker_service = await resolve_service_async()
+
+        # Verify that the async service resolution was successful
+        # The container should return a valid instance implementing IWorkers
         self.assertIsNotNone(
-            path_resolver,
+            worker_service,
             "Async service resolution should return valid instance"
         )
 
-        async def use_service_async() -> str:
+        async def use_service_async() -> int:
             """
-            Simulate async service method execution.
+            Simulate async service method execution with I/O delay.
+
+            Demonstrates using a resolved service in an async context while
+            simulating real-world async operations that might be performed
+            by the service methods.
 
             Returns
             -------
-            str
-                Result from async service method call.
+            int
+                Result from async service method call representing worker count.
             """
+            # Simulate async I/O operation that might occur during service usage
             await asyncio.sleep(0.01)
-            return path_resolver.relativePath("README.md").toString()
+            # Execute the calculate method on the resolved worker service
+            return worker_service.calculate()
 
-        # Test async service method execution
+        # Test async service method execution after resolution
+        # This validates that resolved services function properly in async contexts
         result = await use_service_async()
-        self.assertTrue(
-            result.endswith("README.md"),
-            "Async service method execution should return correct result"
+
+        # Verify that the async service method execution returns expected results
+        # The worker calculation should return a positive integer representing available workers
+        self.assertGreater(
+            result,
+            0,
+            "Async service method execution should return positive worker count"
         )
 
     async def testAsyncDataProcessing(self) -> None:

orionis/foundation/providers/path_resolver_provider.py

@@ -1,43 +0,0 @@
-from orionis.container.providers.service_provider import ServiceProvider
-from orionis.services.paths.contracts.resolver import IResolver
-from orionis.services.paths.resolver import Resolver
-
-class PathResolverProvider(ServiceProvider):
-    """
-    Registers the path resolution service in the application container.
-
-    This provider binds the `IResolver` interface to the `Resolver` implementation,
-    allowing the application to resolve file system paths through dependency injection.
-
-    Attributes
-    ----------
-    app : Application
-        The application container instance inherited from ServiceProvider.
-    """
-
-    def register(self) -> None:
-        """
-        Register the path resolver service in the application container.
-
-        Binds the `IResolver` interface to the `Resolver` implementation as a transient
-        service, with the alias "core.orionis.path_resolver".
-
-        Returns
-        -------
-        None
-        """
-
-        self.app.transient(IResolver, Resolver, alias="core.orionis.path_resolver")
-
-    def boot(self) -> None:
-        """
-        Perform post-registration initialization if needed.
-
-        This method is a placeholder for any actions required after service registration.
-
-        Returns
-        -------
-        None
-        """
-
-        pass

orionis/services/paths/contracts/resolver.py

@@ -1,51 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IResolver(ABC):
-
-    @abstractmethod
-    def relativePath(self, relative_path: str) -> 'IResolver':
-        """
-        Resolves a relative path into an absolute one and validates its existence.
-
-        Parameters
-        ----------
-        relative_path : str
-            The relative path to resolve.
-
-        Returns
-        -------
-        ResolverInterface
-            The instance itself for method chaining.
-
-        Raises
-        ------
-        FileNotFoundError
-            If the resolved path does not exist.
-        ValueError
-            If the resolved path is neither a file nor a directory.
-        """
-        pass
-
-    @abstractmethod
-    def toString(self) -> str:
-        """
-        Returns the resolved path as a string.
-
-        Returns
-        -------
-        str
-            The resolved path.
-        """
-        pass
-
-    @abstractmethod
-    def get(self):
-        """
-        Returns the resolved path as a Path object.
-
-        Returns
-        -------
-        Path
-            The resolved path.
-        """
-        pass

orionis/services/paths/exceptions/__init__.py

@@ -1,7 +0,0 @@
-from .exception import OrionisPathValueException
-from .file import OrionisFileNotFoundException
-
-__all__ = [
-    "OrionisPathValueException",
-    "OrionisFileNotFoundException"
-]

orionis/services/paths/exceptions/exception.py

@@ -1,19 +0,0 @@
-class OrionisPathValueException(Exception):
-
-    def __init__(self, msg: str):
-        """
-        Parameters
-        ----------
-        msg : str
-            Descriptive error message explaining the cause of the exception.
-        """
-        super().__init__(msg)
-
-    def __str__(self) -> str:
-        """
-        Returns
-        -------
-        str
-            Formatted string describing the exception.
-        """
-        return str(self.args[0])

orionis/services/paths/exceptions/file.py

@@ -1,19 +0,0 @@
-class OrionisFileNotFoundException(Exception):
-
-    def __init__(self, msg: str):
-        """
-        Parameters
-        ----------
-        msg : str
-            Descriptive error message explaining the cause of the exception.
-        """
-        super().__init__(msg)
-
-    def __str__(self) -> str:
-        """
-        Returns
-        -------
-        str
-            Formatted string describing the exception.
-        """
-        return str(self.args[0])

orionis/services/paths/resolver.py

@@ -1,95 +0,0 @@
-import os
-from pathlib import Path
-from orionis.services.paths.contracts.resolver import IResolver
-from orionis.services.paths.exceptions import (
-    OrionisFileNotFoundException,
-    OrionisPathValueException
-)
-
-class Resolver(IResolver):
-
-    def __init__(self, root_path: str = None):
-        """
-        Initializes the Resolver instance with the project's root directory.
-
-        Parameters
-        ----------
-        root_path : str, optional
-            The root directory of the project. If not provided, it defaults to the current working directory.
-        """
-        self.base_path = Path(root_path).resolve() if root_path else Path(os.getcwd()).resolve()
-        self.resolved_path = None
-
-    def relativePath(self, relative_path: str) -> 'Resolver':
-        """
-        Resolves a given relative path to an absolute path and validates its existence.
-
-        This method combines the project's root directory with the provided relative path,
-        resolves it to an absolute path, and ensures it exists as either a directory or a file.
-
-        Parameters
-        ----------
-        relative_path : str
-            The relative path to a directory or file to be resolved.
-
-        Returns
-        -------
-        Resolver
-            The current instance of the Resolver class with the resolved path.
-
-        Raises
-        ------
-        OrionisFileNotFoundException
-            If the resolved path does not exist.
-        OrionisPathValueException
-            If the resolved path is neither a valid directory nor a file.
-        """
-        # Combine the base path with the relative path and resolve it
-        resolved_path = (self.base_path / relative_path).resolve()
-
-        # Validate that the path exists
-        if not resolved_path.exists():
-            raise OrionisFileNotFoundException(f"The requested path does not exist: {resolved_path}")
-
-        # Validate that the path is either a directory or a file
-        if not (resolved_path.is_dir() or resolved_path.is_file()):
-            raise OrionisPathValueException(f"The requested path is neither a valid directory nor a file: {resolved_path}")
-
-        # Store the resolved path in the instance variable
-        self.resolved_path = resolved_path
-
-        # Return the current instance
-        return self
-
-    def toString(self) -> str:
-        """
-        Returns the string representation of the resolved path.
-
-        Returns
-        -------
-        str
-            The resolved path as a string.
-        """
-        return str(self.resolved_path)
-
-    def get(self) -> Path:
-        """
-        Returns the resolved path as a Path object.
-
-        Returns
-        -------
-        Path
-            The resolved path.
-        """
-        return self.resolved_path
-
-    def __str__(self) -> str:
-        """
-        Returns the string representation of the resolved path.
-
-        Returns
-        -------
-        str
-            The resolved path as a string.
-        """
-        return str(self.resolved_path)

orionis/support/facades/path_resolver.py

@@ -1,15 +0,0 @@
-from orionis.container.facades.facade import Facade
-
-class PathResolver(Facade):
-
-    @classmethod
-    def getFacadeAccessor(cls):
-        """
-        Returns the binding key for the path resolver service in the container.
-
-        Returns
-        -------
-        str
-            The unique string identifier for the path resolver service, used by the service container.
-        """
-        return "core.orionis.path_resolver"

tests/services/path/test_services_resolver.py

@@ -1,112 +0,0 @@
-import os
-import tempfile
-from pathlib import Path
-from orionis.services.paths.exceptions import OrionisFileNotFoundException
-from orionis.services.paths.resolver import Resolver
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServicesResolver(AsyncTestCase):
-
-    async def testFileNotFound(self):
-        """
-        Test that resolving a non-existent file path raises OrionisFileNotFoundException.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        OrionisFileNotFoundException
-            If the file does not exist.
-        """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            resolver = Resolver(tmpdir)
-            non_existent = "does_not_exist.txt"
-            with self.assertRaises(OrionisFileNotFoundException):
-                resolver.relativePath(non_existent)
-
-    async def testValidFilePath(self):
-        """
-        Test that resolving a valid file path returns the correct absolute path.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        The resolved path ends with the file name and is absolute.
-        """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Create a temporary file inside the temp directory
-            file_path = Path(tmpdir) / "testfile.txt"
-            file_path.write_text("sample content")
-            resolver = Resolver(tmpdir)
-            resolved = resolver.relativePath("testfile.txt").toString()
-            # The resolved path should end with the file name
-            self.assertTrue(resolved.endswith("testfile.txt"))
-            # The resolved path should be absolute
-            self.assertTrue(os.path.isabs(resolved))
-
-    async def testValidDirectoryPath(self):
-        """
-        Test that resolving a valid directory path returns the correct absolute path.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        The resolved path ends with the directory name and is absolute.
-        """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Create a subdirectory inside the temp directory
-            subdir = Path(tmpdir) / "subdir"
-            subdir.mkdir()
-            resolver = Resolver(tmpdir)
-            resolved = resolver.relativePath("subdir").toString()
-            self.assertTrue(resolved.endswith("subdir"))
-            self.assertTrue(os.path.isabs(resolved))
-
-    async def testOtherBasePath(self):
-        """
-        Test that providing a different base path to Resolver works as expected.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        The resolved path ends with the file name and is absolute.
-        """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Create a file in a subdirectory
-            subdir = Path(tmpdir) / "base"
-            subdir.mkdir()
-            file_path = subdir / "file.txt"
-            file_path.write_text("data")
-            resolver = Resolver(str(subdir))
-            resolved = resolver.relativePath("file.txt").toString()
-            self.assertTrue(resolved.endswith("file.txt"))
-            self.assertTrue(os.path.isabs(resolved))
-
-    async def testEqualOutputString(self):
-        """
-        Test that the string representation of the resolved path matches the output of toString().
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        The string representation of the resolved path matches the output of toString().
-        """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            file_path = Path(tmpdir) / "file.txt"
-            file_path.write_text("abc")
-            resolver = Resolver(tmpdir).relativePath("file.txt")
-            self.assertEqual(resolver.toString(), str(resolver))