dissect.target 3.20.2.dev49__tar.gz → 3.20.2.dev51__tar.gz

{dissect_target-3.20.2.dev49/dissect.target.egg-info → dissect_target-3.20.2.dev51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dissect.target
-Version: 3.20.2.dev49
+Version: 3.20.2.dev51
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.20.2.dev49 → dissect_target-3.20.2.dev51}/dissect/target/container.py

@@ -169,7 +169,7 @@ class Container(io.IOBase):
 
         Override this if you need to clean-up anything.
         """
-        raise NotImplementedError()
+        pass
 
 
 def register(module: str, class_name: str, internal: bool = True):

{dissect_target-3.20.2.dev49 → dissect_target-3.20.2.dev51}/dissect/target/exceptions.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import errno
 import os
 import sys
 import traceback
@@ -76,22 +77,32 @@ class PluginNotFoundError(PluginError):
 class FileNotFoundError(FilesystemError, FileNotFoundError):
     """The requested path could not be found."""
 
+    errno = errno.ENOENT
+
 
 class IsADirectoryError(FilesystemError, IsADirectoryError):
     """The entry is a directory."""
 
+    errno = errno.EISDIR
+
 
 class NotADirectoryError(FilesystemError, NotADirectoryError):
     """The entry is not a directory."""
 
+    errno = errno.ENOTDIR
+
 
 class NotASymlinkError(FilesystemError):
     """The entry is not a symlink."""
 
+    errno = errno.EINVAL
+
 
 class SymlinkRecursionError(FilesystemError):
     """A symlink loop is detected for the entry."""
 
+    errno = errno.ELOOP
+
 
 class RegistryError(Error):
     """A registry error occurred."""

{dissect_target-3.20.2.dev49 → dissect_target-3.20.2.dev51}/dissect/target/helpers/compat/path_310.py

@@ -20,23 +20,15 @@ from __future__ import annotations
 import fnmatch
 import re
 from pathlib import Path, PurePath, _Accessor, _PosixFlavour
-from stat import S_ISBLK, S_ISCHR, S_ISFIFO, S_ISSOCK
-from typing import IO, TYPE_CHECKING, Any, Callable, Iterator, Optional
+from typing import IO, TYPE_CHECKING, Any, Callable, Iterator
 
 from dissect.target import filesystem
 from dissect.target.exceptions import FilesystemError, SymlinkRecursionError
-from dissect.target.helpers.compat.path_common import (
-    _DissectPathParents,
-    io_open,
-    isjunction,
-    realpath,
-    scandir,
-)
-from dissect.target.helpers.polypath import normalize
+from dissect.target.helpers import polypath
+from dissect.target.helpers.compat import path_common
 
 if TYPE_CHECKING:
     from dissect.target.filesystem import Filesystem, FilesystemEntry
-    from dissect.target.helpers.compat.path_common import _DissectScandirIterator
     from dissect.target.helpers.fsutil import stat_result
 
 
@@ -82,9 +74,9 @@ class _DissectAccessor(_Accessor):
         path: TargetPath,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -93,15 +85,15 @@ class _DissectAccessor(_Accessor):
         Note: in contrast to regular Python, the mode is binary by default. Text mode
         has to be explicitly specified. Buffering is also disabled by default.
         """
-        return io_open(path, mode, buffering, encoding, errors, newline)
+        return path_common.io_open(path, mode, buffering, encoding, errors, newline)
 
     @staticmethod
-    def listdir(path: TargetPath) -> Iterator[str]:
+    def listdir(path: TargetPath) -> list[str]:
         return path.get().listdir()
 
     @staticmethod
-    def scandir(path: TargetPath) -> _DissectScandirIterator:
-        return scandir(path)
+    def scandir(path: TargetPath) -> path_common._DissectScandirIterator:
+        return path_common.scandir(path)
 
     @staticmethod
     def chmod(path: TargetPath, mode: int, *, follow_symlinks: bool = True) -> None:
@@ -163,10 +155,10 @@ class _DissectAccessor(_Accessor):
     def expanduser(path: str) -> str:
         raise NotImplementedError("TargetPath.expanduser() is unsupported")
 
-    realpath = staticmethod(realpath)
+    realpath = staticmethod(path_common.realpath)
 
     # NOTE: Forward compatibility with CPython >= 3.12
-    isjunction = staticmethod(isjunction)
+    isjunction = staticmethod(path_common.isjunction)
 
 
 _dissect_accessor = _DissectAccessor()
@@ -193,7 +185,7 @@ class PureDissectPath(PurePath):
         path_args = []
         for arg in args[1:]:
             if isinstance(arg, str):
-                arg = normalize(arg, alt_separator=alt_separator)
+                arg = polypath.normalize(arg, alt_separator=alt_separator)
             path_args.append(arg)
 
         self = super()._from_parts(path_args)
@@ -247,8 +239,8 @@ class PureDissectPath(PurePath):
         return result
 
     @property
-    def parents(self) -> _DissectPathParents:
-        return _DissectPathParents(self)
+    def parents(self) -> path_common._DissectPathParents:
+        return path_common._DissectPathParents(self)
 
 
 class TargetPath(Path, PureDissectPath):
@@ -382,9 +374,9 @@ class TargetPath(Path, PureDissectPath):
         self,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -402,7 +394,7 @@ class TargetPath(Path, PureDissectPath):
         raise NotImplementedError("TargetPath.write_bytes() is unsupported")
 
     def write_text(
-        self, data: str, encoding: Optional[str] = None, errors: Optional[str] = None, newline: Optional[str] = None
+        self, data: str, encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> int:
         """
         Open the file in text mode, write to it, and close the file.
@@ -417,45 +409,6 @@ class TargetPath(Path, PureDissectPath):
         obj = self._from_parts((self._fs, path))
         return obj
 
-    def exists(self) -> bool:
-        """
-        Whether this path exists.
-        """
-        try:
-            # .exists() must resolve possible symlinks
-            self.get().stat()
-            return True
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_dir(self) -> bool:
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return self.get().is_dir()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_file(self) -> bool:
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return self.get().is_file()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_symlink(self) -> bool:
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return self.get().is_symlink()
-        except (FilesystemError, ValueError):
-            return False
-
     # NOTE: Forward compatibility with CPython >= 3.12
     def is_junction(self) -> bool:
         """
@@ -463,42 +416,6 @@ class TargetPath(Path, PureDissectPath):
         """
         return self._accessor.isjunction(self)
 
-    def is_block_device(self) -> bool:
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_char_device(self) -> bool:
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_fifo(self) -> bool:
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_socket(self) -> bool:
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
     def expanduser(self) -> TargetPath:
         """Return a new path with expanded ~ and ~user constructs
         (as returned by os.path.expanduser)

{dissect_target-3.20.2.dev49 → dissect_target-3.20.2.dev51}/dissect/target/helpers/compat/path_311.py

@@ -17,34 +17,21 @@ Commit hash we're in sync with: 846a23d
 Notes:
     - CPython 3.11 ditched the _Accessor class, so we override the methods that should use it
 """
+
 from __future__ import annotations
 
 import fnmatch
 import re
 from pathlib import Path, PurePath, _PosixFlavour
-from stat import S_ISBLK, S_ISCHR, S_ISFIFO, S_ISSOCK
-from typing import IO, TYPE_CHECKING, Any, Callable, Iterator, Optional
+from typing import IO, TYPE_CHECKING, Any, Callable, Iterator
 
 from dissect.target import filesystem
-from dissect.target.exceptions import (
-    FileNotFoundError,
-    FilesystemError,
-    NotADirectoryError,
-    NotASymlinkError,
-    SymlinkRecursionError,
-)
-from dissect.target.helpers.compat.path_common import (
-    _DissectPathParents,
-    io_open,
-    isjunction,
-    realpath,
-    scandir,
-)
-from dissect.target.helpers.polypath import normalize
+from dissect.target.exceptions import FilesystemError, SymlinkRecursionError
+from dissect.target.helpers import polypath
+from dissect.target.helpers.compat import path_common
 
 if TYPE_CHECKING:
     from dissect.target.filesystem import Filesystem, FilesystemEntry
-    from dissect.target.helpers.compat.path_common import _DissectScandirIterator
     from dissect.target.helpers.fsutil import stat_result
 
 
@@ -101,7 +88,7 @@ class PureDissectPath(PurePath):
         path_args = []
         for arg in args[1:]:
             if isinstance(arg, str):
-                arg = normalize(arg, alt_separator=alt_separator)
+                arg = polypath.normalize(arg, alt_separator=alt_separator)
             path_args.append(arg)
 
         self = super()._from_parts(path_args)
@@ -155,8 +142,8 @@ class PureDissectPath(PurePath):
         return result
 
     @property
-    def parents(self) -> _DissectPathParents:
-        return _DissectPathParents(self)
+    def parents(self) -> path_common._DissectPathParents:
+        return path_common._DissectPathParents(self)
 
 
 class TargetPath(Path, PureDissectPath):
@@ -193,7 +180,7 @@ class TargetPath(Path, PureDissectPath):
         """Iterate over the files in this directory.  Does not yield any
         result for the special paths '.' and '..'.
         """
-        for entry in scandir(self):
+        for entry in path_common.scandir(self):
             if entry.name in {".", ".."}:
                 # Yielding a path object for these makes little sense
                 continue
@@ -201,8 +188,8 @@ class TargetPath(Path, PureDissectPath):
             child_path._entry = entry
             yield child_path
 
-    def _scandir(self) -> _DissectScandirIterator:
-        return scandir(self)
+    def _scandir(self) -> path_common._DissectScandirIterator:
+        return path_common.scandir(self)
 
     # NOTE: Forward compatibility with CPython >= 3.12
     def walk(
@@ -267,7 +254,7 @@ class TargetPath(Path, PureDissectPath):
         normalizing it.
         """
 
-        s = realpath(self, strict=strict)
+        s = path_common.realpath(self, strict=strict)
         p = self._from_parts((self._fs, s))
 
         # In non-strict mode, realpath() doesn't raise on symlink loops.
@@ -306,9 +293,9 @@ class TargetPath(Path, PureDissectPath):
         self,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -317,7 +304,7 @@ class TargetPath(Path, PureDissectPath):
         Note: in contrast to regular Python, the mode is binary by default. Text mode
         has to be explicitly specified. Buffering is also disabled by default.
         """
-        return io_open(self, mode, buffering, encoding, errors, newline)
+        return path_common.io_open(self, mode, buffering, encoding, errors, newline)
 
     def write_bytes(self, data: bytes) -> int:
         """
@@ -326,7 +313,7 @@ class TargetPath(Path, PureDissectPath):
         raise NotImplementedError("TargetPath.write_bytes() is unsupported")
 
     def write_text(
-        self, data: str, encoding: Optional[str] = None, errors: Optional[str] = None, newline: Optional[str] = None
+        self, data: str, encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> int:
         """
         Open the file in text mode, write to it, and close the file.
@@ -430,36 +417,6 @@ class TargetPath(Path, PureDissectPath):
         """
         raise NotImplementedError("TargetPath.link_to() is unsupported")
 
-    def exists(self) -> bool:
-        """
-        Whether this path exists.
-        """
-        try:
-            # .exists() must resolve possible symlinks
-            self.get().stat()
-            return True
-        except (FileNotFoundError, NotADirectoryError, NotASymlinkError, SymlinkRecursionError, ValueError):
-            return False
-
-    def is_dir(self) -> bool:
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return self.get().is_dir()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_file(self) -> bool:
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return self.get().is_file()
-        except (FilesystemError, ValueError):
-            return False
-
     def is_mount(self) -> bool:
         """
         Check if this path is a POSIX mount point
@@ -480,57 +437,12 @@ class TargetPath(Path, PureDissectPath):
         parent_ino = self.parent.stat().st_ino
         return ino == parent_ino
 
-    def is_symlink(self) -> bool:
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return self.get().is_symlink()
-        except (FilesystemError, ValueError):
-            return False
-
     # NOTE: Forward compatibility with CPython >= 3.12
     def is_junction(self) -> bool:
         """
         Whether this path is a junction.
         """
-        return isjunction(self)
-
-    def is_block_device(self) -> bool:
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_char_device(self) -> bool:
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_fifo(self) -> bool:
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_socket(self) -> bool:
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
+        return path_common.isjunction(self)
 
     def expanduser(self) -> TargetPath:
         """Return a new path with expanded ~ and ~user constructs

{dissect_target-3.20.2.dev49 → dissect_target-3.20.2.dev51}/dissect/target/helpers/compat/path_312.py

@@ -12,7 +12,7 @@ Yes, we know, this is playing with fire and it can break on new CPython releases
 The implementation is split up in multiple files, one for each CPython version.
 You're currently looking at the CPython 3.12 implementation.
 
-Commit hash we're in sync with:
+Commit hash we're in sync with: f49221a
 
 Notes:
     - CPython 3.12 changed a lot in preparation of proper subclassing, so our patches differ
@@ -25,22 +25,15 @@ from __future__ import annotations
 import posixpath
 import sys
 from pathlib import Path, PurePath
-from stat import S_ISBLK, S_ISCHR, S_ISFIFO, S_ISSOCK
-from typing import IO, TYPE_CHECKING, Iterator, Optional
+from typing import IO, TYPE_CHECKING, Iterator
 
 from dissect.target import filesystem
 from dissect.target.exceptions import FilesystemError, SymlinkRecursionError
 from dissect.target.helpers import polypath
-from dissect.target.helpers.compat.path_common import (
-    io_open,
-    isjunction,
-    realpath,
-    scandir,
-)
+from dissect.target.helpers.compat import path_common
 
 if TYPE_CHECKING:
     from dissect.target.filesystem import Filesystem, FilesystemEntry
-    from dissect.target.helpers.compat.path_common import _DissectScandirIterator
     from dissect.target.helpers.fsutil import stat_result
 
 
@@ -69,7 +62,7 @@ class _DissectFlavour:
 
     splitdrive = staticmethod(posixpath.splitdrive)
 
-    def splitroot(self, part: str) -> tuple[str, str]:
+    def splitroot(self, part: str) -> tuple[str, str, str]:
         return polypath.splitroot(part, alt_separator=self.altsep)
 
     def join(self, *args) -> str:
@@ -93,14 +86,14 @@ class _DissectFlavour:
         parent_ino = path.parent.stat().st_ino
         return ino == parent_ino
 
-    isjunction = staticmethod(isjunction)
+    isjunction = staticmethod(path_common.isjunction)
 
     samestat = staticmethod(posixpath.samestat)
 
     def isabs(self, path: str) -> bool:
         return polypath.isabs(path, alt_separator=self.altsep)
 
-    realpath = staticmethod(realpath)
+    realpath = staticmethod(path_common.realpath)
 
 
 class PureDissectPath(PurePath):
@@ -114,7 +107,7 @@ class PureDissectPath(PurePath):
         if not isinstance(fs, filesystem.Filesystem):
             raise TypeError(
                 "invalid PureDissectPath initialization: missing filesystem, "
-                "got %r (this might be a bug, please report)" % pathsegments
+                "got %r (this might be a bug, please report)" % (fs, *pathsegments)
             )
 
         alt_separator = fs.alt_separator
@@ -177,91 +170,13 @@ class TargetPath(Path, PureDissectPath):
         else:
             return self.get().lstat()
 
-    def exists(self, *, follow_symlinks: bool = True) -> bool:
-        """
-        Whether this path exists.
-
-        This method normally follows symlinks; to check whether a symlink exists,
-        add the argument follow_symlinks=False.
-        """
-        try:
-            # .exists() must resolve possible symlinks
-            self.stat(follow_symlinks=follow_symlinks)
-            return True
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_dir(self) -> bool:
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return self.get().is_dir()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_file(self) -> bool:
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return self.get().is_file()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_symlink(self) -> bool:
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return self.get().is_symlink()
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_block_device(self) -> bool:
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_char_device(self) -> bool:
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_fifo(self) -> bool:
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
-    def is_socket(self) -> bool:
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except (FilesystemError, ValueError):
-            return False
-
     def open(
         self,
         mode: str = "rb",
         buffering: int = 0,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> IO:
         """Open file and return a stream.
 
@@ -270,7 +185,7 @@ class TargetPath(Path, PureDissectPath):
         Note: in contrast to regular Python, the mode is binary by default. Text mode
         has to be explicitly specified. Buffering is also disabled by default.
         """
-        return io_open(self, mode, buffering, encoding, errors, newline)
+        return path_common.io_open(self, mode, buffering, encoding, errors, newline)
 
     def write_bytes(self, data: bytes) -> int:
         """
@@ -279,7 +194,7 @@ class TargetPath(Path, PureDissectPath):
         raise NotImplementedError("TargetPath.write_bytes() is unsupported")
 
     def write_text(
-        self, data: str, encoding: Optional[str] = None, errors: Optional[str] = None, newline: Optional[str] = None
+        self, data: str, encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> int:
         """
         Open the file in text mode, write to it, and close the file.
@@ -290,7 +205,7 @@ class TargetPath(Path, PureDissectPath):
         """Iterate over the files in this directory.  Does not yield any
         result for the special paths '.' and '..'.
         """
-        for entry in scandir(self):
+        for entry in path_common.scandir(self):
             if entry.name in {".", ".."}:
                 # Yielding a path object for these makes little sense
                 continue
@@ -298,8 +213,8 @@ class TargetPath(Path, PureDissectPath):
             child_path._entry = entry
             yield child_path
 
-    def _scandir(self) -> _DissectScandirIterator:
-        return scandir(self)
+    def _scandir(self) -> path_common._DissectScandirIterator:
+        return path_common.scandir(self)
 
     @classmethod
     def cwd(cls) -> TargetPath: