orionis 0.444.0__py3-none-any.whl → 0.446.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.446.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/test/core/unit_test.py

@@ -21,30 +21,10 @@ from orionis.test.contracts.test_result import IOrionisTestResult
 from orionis.test.contracts.unit_test import IUnitTest
 from orionis.test.entities.result import TestResult
 from orionis.test.enums import TestStatus
-from orionis.test.exceptions import (
-    OrionisTestFailureException,
-    OrionisTestPersistenceError,
-    OrionisTestValueError,
-)
+from orionis.test.exceptions import *
 from orionis.test.output.printer import TestPrinter
 from orionis.test.records.logs import TestLogs
-from orionis.test.validators import (
-    ValidExecutionMode,
-    ValidFailFast,
-    ValidPersistent,
-    ValidPersistentDriver,
-    ValidPrintResult,
-    ValidThrowException,
-    ValidVerbosity,
-    ValidWebReport,
-    ValidWorkers,
-    ValidBasePath,
-    ValidFolderPath,
-    ValidNamePattern,
-    ValidPattern,
-    ValidTags,
-    ValidModuleName,
-)
+from orionis.test.validators import *
 from orionis.test.view.render import TestingResultRender
 
 class UnitTest(IUnitTest):
@@ -54,53 +34,6 @@ class UnitTest(IUnitTest):
     Advanced unit testing manager for the Orionis framework.
 
     This class provides mechanisms for discovering, executing, and reporting unit tests with extensive configurability. It supports sequential and parallel execution, test filtering by name or tags, and detailed result tracking including execution times, error messages, and tracebacks.
-
-    Attributes
-    ----------
-    __app : Optional[IApplication]
-        Application instance for dependency injection.
-    __verbosity : Optional[int]
-        Verbosity level for test output.
-    __execution_mode : Optional[str]
-        Execution mode for tests ('SEQUENTIAL' or 'PARALLEL').
-    __max_workers : Optional[int]
-        Maximum number of workers for parallel execution.
-    __fail_fast : Optional[bool]
-        Whether to stop on first failure.
-    __throw_exception : Optional[bool]
-        Whether to raise exceptions on test failures.
-    __persistent : Optional[bool]
-        Whether to persist test results.
-    __persistent_driver : Optional[str]
-        Persistence driver ('sqlite' or 'json').
-    __web_report : Optional[bool]
-        Whether to generate a web report.
-    __folder_path : Optional[str]
-        Folder path for test discovery.
-    __base_path : Optional[str]
-        Base directory for test discovery.
-    __pattern : Optional[str]
-        File name pattern for test discovery.
-    __test_name_pattern : Optional[str]
-        Pattern for filtering test names.
-    __tags : Optional[List[str]]
-        Tags for filtering tests.
-    __module_name : Optional[str]
-        Module name for test discovery.
-    __loader : unittest.TestLoader
-        Loader for discovering tests.
-    __suite : unittest.TestSuite
-        Test suite containing discovered tests.
-    __discovered_tests : List
-        List of discovered test metadata.
-    __printer : Optional[TestPrinter]
-        Utility for printing test results.
-    __output_buffer : Optional[str]
-        Buffer for capturing standard output.
-    __error_buffer : Optional[str]
-        Buffer for capturing error output.
-    __result : Optional[dict]
-        Result summary of the test execution.
     """
 
     def __init__(
@@ -117,6 +50,7 @@ class UnitTest(IUnitTest):
         -------
         None
         """
+
         # Application instance for dependency injection
         self.__app: Optional[IApplication] = app or Orionis()
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.444.0
+Version: 0.446.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.446.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=cmZ_JrSV8hHiQ6tIZr04kISqOKd-MrIiXmwLgvU-2EE,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
@@ -318,7 +309,7 @@ orionis/test/contracts/render.py,sha256=wpDQzUtT0r8KFZ7zPcxWHXQ1EVNKxzA_rZ6ZKUcZ
 orionis/test/contracts/test_result.py,sha256=SNXJ2UerkweYn7uCT0i0HmMGP0XBrL_9KJs-0ZvIYU4,4002
 orionis/test/contracts/unit_test.py,sha256=PSnjEyM-QGQ3Pm0ZOqaa8QdPOtilGBVO4R87JYdVa-8,5386
 orionis/test/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/core/unit_test.py,sha256=IIpPLM4pXZKCpKAZ-0PPatGuWjBXxgjKQxB8IJLB1zY,63310
+orionis/test/core/unit_test.py,sha256=7oHQiWfMMFQ3rsuKHBRS34Aqbk5nTinsGVh44OAkHE0,61051
 orionis/test/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/entities/result.py,sha256=IMAd1AiwOf2z8krTDBFMpQe_1PG4YJ5Z0qpbr9xZwjg,4507
 orionis/test/enums/__init__.py,sha256=M3imAgMvKFTKg55FbtVoY3zxj7QRY9AfaUWxiSZVvn4,66
@@ -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.446.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.446.0.dist-info/METADATA,sha256=iD7rp-OlLM2n4AjNDNrcjTyKFl70G_gD165H4065uXo,4772
+orionis-0.446.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.446.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.446.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.446.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))