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

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))