dissect.target 3.23.dev63__tar.gz → 3.23.dev65__tar.gz

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.23.dev63
+Version: 3.23.dev65
 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.23.dev63 → dissect_target-3.23.dev65}/dissect/target/filesystems/cb.py

@@ -5,7 +5,6 @@ from datetime import datetime, timezone
 from enum import IntEnum
 from typing import TYPE_CHECKING, Any, BinaryIO
 
-from cbc_sdk.live_response_api import LiveResponseError, LiveResponseSession
 from dissect.util import ts
 
 from dissect.target.exceptions import FileNotFoundError, NotADirectoryError
@@ -15,6 +14,13 @@ from dissect.target.helpers import fsutil
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
+try:
+    from cbc_sdk.live_response_api import LiveResponseError, LiveResponseSession
+
+    HAS_CARBON_BLACK = True
+except ImportError:
+    HAS_CARBON_BLACK = False
+
 CB_TIMEFORMAT = "%Y-%m-%dT%H:%M:%S%fZ"
 
 
@@ -28,6 +34,11 @@ class CbFilesystem(Filesystem):
     __type__ = "cb"
 
     def __init__(self, session: LiveResponseSession, prefix: str, *args, **kwargs):
+        if not HAS_CARBON_BLACK:
+            raise ImportError(
+                "Required dependency 'carbon-black-cloud-sdk-python' is missing, install with 'pip install dissect.target[cb]'"  # noqa: E501
+            )
+
         self.session = session
         self.prefix = prefix.lower()
 

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/dissect/target/filesystems/smb.py

@@ -5,16 +5,6 @@ import stat
 from typing import TYPE_CHECKING, BinaryIO
 
 from dissect.util.stream import AlignedStream
-from impacket.nt_errors import STATUS_NOT_A_DIRECTORY
-from impacket.smb import ATTR_DIRECTORY, SharedFile
-from impacket.smb3structs import (
-    FILE_ATTRIBUTE_NORMAL,
-    FILE_NON_DIRECTORY_FILE,
-    FILE_OPEN,
-    FILE_READ_DATA,
-    FILE_SHARE_READ,
-)
-from impacket.smbconnection import SessionError, SMBConnection
 
 from dissect.target.exceptions import (
     FileNotFoundError,
@@ -28,6 +18,22 @@ from dissect.target.helpers import fsutil
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
+try:
+    from impacket.nt_errors import STATUS_NOT_A_DIRECTORY
+    from impacket.smb import ATTR_DIRECTORY, SharedFile
+    from impacket.smb3structs import (
+        FILE_ATTRIBUTE_NORMAL,
+        FILE_NON_DIRECTORY_FILE,
+        FILE_OPEN,
+        FILE_READ_DATA,
+        FILE_SHARE_READ,
+    )
+    from impacket.smbconnection import SessionError, SMBConnection
+
+    HAS_IMPACKET = True
+except ImportError:
+    HAS_IMPACKET = False
+
 log = logging.getLogger(__name__)
 
 
@@ -38,6 +44,12 @@ class SmbFilesystem(Filesystem):
 
     def __init__(self, conn: SMBConnection, share_name: str, *args, **kwargs):
         super().__init__(None, *args, **kwargs, alt_separator="\\", case_sensitive=False)
+
+        if not HAS_IMPACKET:
+            raise ImportError(
+                "Required dependency 'impacket' is missing, install with 'pip install dissect.target[smb]'"
+            )
+
         self.conn = conn
         self.share_name = share_name
 

dissect_target-3.23.dev65/dissect/target/helpers/lazy.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+
+class LazyImport:
+    def __init__(self, module_name: str):
+        self._module_name = module_name
+        self._module = None
+        self._loaded = False
+
+    def __repr__(self) -> str:
+        return f"<lazy {self._module_name} loaded={self._loaded} failed={isinstance(self._module, FailedImport)}>"
+
+    def __getattr__(self, attr: str) -> LazyAttr:
+        return LazyAttr(self, attr)
+
+    def _import(self) -> None:
+        if not self._module:
+            try:
+                self._module = importlib.import_module(self._module_name)
+            except Exception as e:
+                self._module = FailedImport(self, e)
+            finally:
+                self._loaded = True
+
+
+class FailedImport:
+    def __init__(self, module: LazyImport, exc: Exception):
+        self._module = module
+        self._exc = exc
+
+    def __getattr__(self, attr: str) -> None:
+        self._error()
+
+    def __call__(self, *args, **kwargs) -> None:
+        self._error()
+
+    def _error(self) -> None:
+        raise ImportError(f"Failed to lazily import {self._module._module_name}: {self._exc}")
+
+
+class LazyAttr:
+    def __init__(self, module: LazyImport, attr: str):
+        self._module = module
+        self._attr = attr
+        self._realattr = None
+        self._loaded = False
+        self._exc = None
+
+    def __repr__(self) -> str:
+        return (
+            f"<lazyattr {self._module._module_name}.{self._attr} loaded={self._loaded} failed={self._exc is not None}>"
+        )
+
+    @property
+    def __doc__(self) -> str:
+        try:
+            return self._load().__doc__
+        except Exception as e:
+            return f"Failed to load docstring: {e}"
+
+    def __getattr__(self, attr: str) -> Any:
+        return getattr(self._load(), attr)
+
+    def __call__(self, *args, **kwargs) -> Any:
+        return self._load()(*args, **kwargs)
+
+    def _load(self) -> Any:
+        if not self._loaded:
+            self._module._import()
+            try:
+                self._realattr = getattr(self._module._module, self._attr)
+            except Exception as e:
+                self._exc = e
+                raise
+            finally:
+                self._loaded = True
+
+        if self._exc:
+            raise self._exc
+
+        return self._realattr
+
+
+def import_lazy(module_name: str) -> LazyImport:
+    return LazyImport(module_name)

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/dissect/target/loaders/cb.py

@@ -4,13 +4,6 @@ import ipaddress
 from functools import cached_property
 from typing import TYPE_CHECKING
 
-try:
-    from cbc_sdk.errors import CredentialError
-    from cbc_sdk.platform import Device
-    from cbc_sdk.rest_api import CBCloudAPI
-except ImportError:
-    raise ImportError("Please install 'carbon-black-cloud-sdk-python' to use the 'cb://' target.")
-
 from dissect.util import ts
 
 from dissect.target.exceptions import (
@@ -39,6 +32,15 @@ if TYPE_CHECKING:
 
     from dissect.target.target import Target
 
+try:
+    from cbc_sdk.errors import CredentialError
+    from cbc_sdk.platform import Device
+    from cbc_sdk.rest_api import CBCloudAPI
+
+    HAS_CARBON_BLACK = True
+except ImportError:
+    HAS_CARBON_BLACK = False
+
 
 class CbLoader(Loader):
     """Use Carbon Black endpoints as targets using Live Response.
@@ -51,6 +53,11 @@ class CbLoader(Loader):
     def __init__(self, path: Path, parsed_path: ParseResult | None = None):
         super().__init__(path, parsed_path=parsed_path, resolve=False)
 
+        if not HAS_CARBON_BLACK:
+            raise ImportError(
+                "Required dependency 'carbon-black-cloud-sdk-python' is missing, install with 'pip install dissect.target[cb]'"  # noqa: E501
+            )
+
         self.host = self.parsed_path.path.strip("/")
         instance = self.parsed_path.hostname
 

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/dissect/target/loaders/mqtt.py

@@ -18,7 +18,6 @@ from struct import pack, unpack_from
 from threading import Thread
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, TypeVar
 
-import paho.mqtt.client as mqtt
 from dissect.util.stream import AlignedStream
 
 from dissect.target.containers.raw import RawContainer
@@ -31,6 +30,13 @@ if TYPE_CHECKING:
 
     from dissect.target.target import Target
 
+try:
+    import paho.mqtt.client as mqtt
+
+    HAS_PAHO = True
+except ImportError:
+    HAS_PAHO = False
+
 log = logging.getLogger(__name__)
 
 DISK_INDEX_OFFSET = 9
@@ -299,6 +305,9 @@ class Broker:
         self.password = password
         self.command = kwargs.get("command")
 
+        if not HAS_PAHO:
+            raise ImportError("Required dependency 'paho' is missing, install with 'pip install dissect.target[mqtt]'")
+
     def clear_cache(self) -> None:
         self.index = {}
 

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/dissect/target/loaders/smb.py

@@ -7,9 +7,6 @@ from typing import TYPE_CHECKING
 
 from dissect.regf import regf
 from dissect.util import ts
-from impacket.dcerpc.v5 import rpcrt, rrp, scmr, transport
-from impacket.dcerpc.v5.rpcrt import DCERPCException
-from impacket.smbconnection import SessionError, SMBConnection
 
 from dissect.target.exceptions import (
     LoaderError,
@@ -37,6 +34,15 @@ if TYPE_CHECKING:
 
     from dissect.target.target import Target
 
+try:
+    from impacket.dcerpc.v5 import rpcrt, rrp, scmr, transport
+    from impacket.dcerpc.v5.rpcrt import DCERPCException
+    from impacket.smbconnection import SessionError, SMBConnection
+
+    HAS_IMPACKET = True
+except ImportError:
+    HAS_IMPACKET = False
+
 
 class SmbLoader(Loader):
     """Use remote SMB servers as targets.
@@ -84,6 +90,11 @@ class SmbLoader(Loader):
     def __init__(self, path: Path, parsed_path: ParseResult | None = None):
         super().__init__(path, parsed_path=parsed_path, resolve=False)
 
+        if not HAS_IMPACKET:
+            raise ImportError(
+                "Required dependency 'impacket' is missing, install with 'pip install dissect.target[smb]'"
+            )
+
         if parsed_path is None:
             raise LoaderError("Missing URI connection details")
 
@@ -168,7 +179,6 @@ class SmbLoader(Loader):
                     mount_name = share_name.lower().replace("$", ":")
 
                 target.fs.mount(mount_name, smb_filesystem)
-
             except SessionError as e:
                 target.log.warning("Failed to mount share '%s', reason: %s", share_name, e)
 

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/dissect.target.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.23.dev63
+Version: 3.23.dev65
 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.23.dev63 → dissect_target-3.23.dev65}/dissect.target.egg-info/SOURCES.txt

@@ -501,6 +501,7 @@ tests/helpers/test_docs.py
 tests/helpers/test_fsutil.py
 tests/helpers/test_hashutil.py
 tests/helpers/test_keychain.py
+tests/helpers/test_lazy.py
 tests/helpers/test_loaderutil.py
 tests/helpers/test_localeutil.py
 tests/helpers/test_modifier.py

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/tests/conftest.py

@@ -101,8 +101,10 @@ def clear_lazy_imports() -> None:
         volume.LOGICAL_VOLUME_MANAGERS,
         volume.ENCRYPTED_VOLUME_MANAGERS,
     ):
-        lazy_attr._realattr = None
-        lazy_attr.module._module = None
+        lazy_attr._loaded = False
+        lazy_attr._exc = None
+        lazy_attr._module._module = None
+        lazy_attr._module._loaded = False
 
 
 def make_mock_target(tmp_path: pathlib.Path) -> Iterator[Target]:

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/tests/filesystems/test_cb.py

@@ -10,6 +10,9 @@ from dissect.target.exceptions import NotADirectoryError
 
 def test_cb_filesystem_windows(monkeypatch: pytest.MonkeyPatch) -> None:
     with monkeypatch.context() as m:
+        if "dissect.target.filesystems.cb" in sys.modules:
+            m.delitem(sys.modules, "dissect.target.filesystems.cb")
+
         mock_cbc_sdk = MagicMock()
         m.setitem(sys.modules, "cbc_sdk", mock_cbc_sdk)
         m.setitem(sys.modules, "cbc_sdk.live_response_api", mock_cbc_sdk.live_response_api)

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/tests/filesystems/test_smb.py

@@ -10,6 +10,9 @@ from dissect.target.exceptions import NotADirectoryError
 
 def test_smb_filesystem_windows(monkeypatch: pytest.MonkeyPatch) -> None:
     with monkeypatch.context() as m:
+        if "dissect.target.filesystems.smb" in sys.modules:
+            m.delitem(sys.modules, "dissect.target.filesystems.smb")
+
         mock_impacket = MagicMock()
         m.setitem(sys.modules, "impacket", mock_impacket)
         m.setitem(sys.modules, "impacket.nt_errors", mock_impacket.nt_errors)

dissect_target-3.23.dev65/tests/helpers/test_lazy.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from types import ModuleType
+from unittest.mock import patch
+
+import pytest
+
+from dissect.target.helpers.lazy import import_lazy
+
+
+def test_working() -> None:
+    mock_module = ModuleType("mock")
+    mock_module.function = lambda: "foo"
+
+    with patch("importlib.import_module") as mock_import_module:
+        mock_import_module.return_value = mock_module
+
+        lazy_mod = import_lazy("mock")
+        lazy_attr = lazy_mod.function
+
+        assert repr(lazy_mod) == "<lazy mock loaded=False failed=False>"
+        assert repr(lazy_attr) == "<lazyattr mock.function loaded=False failed=False>"
+
+        assert lazy_attr() == "foo"
+
+        assert repr(lazy_mod) == "<lazy mock loaded=True failed=False>"
+        assert repr(lazy_attr) == "<lazyattr mock.function loaded=True failed=False>"
+
+
+def test_failing_import() -> None:
+    with patch("importlib.import_module") as mock_import_module:
+        mock_import_module.side_effect = ImportError("Module not found")
+
+        lazy_mod = import_lazy("nonexistent")
+        lazy_attr = lazy_mod.function
+
+        with pytest.raises(ImportError, match="Failed to lazily import nonexistent: Module not found"):
+            lazy_attr()
+
+        assert repr(lazy_mod) == "<lazy nonexistent loaded=True failed=True>"
+        assert repr(lazy_attr) == "<lazyattr nonexistent.function loaded=True failed=True>"
+
+
+def test_missing_attr() -> None:
+    mock_module = ModuleType("mock")
+
+    with patch("importlib.import_module") as mock_import_module:
+        mock_import_module.return_value = mock_module
+
+        lazy_mod = import_lazy("mock")
+        lazy_attr = lazy_mod.function
+
+        with pytest.raises(AttributeError, match="module 'mock' has no attribute 'function'"):
+            lazy_attr()
+
+        assert repr(lazy_mod) == "<lazy mock loaded=True failed=False>"
+        assert repr(lazy_attr) == "<lazyattr mock.function loaded=True failed=True>"

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/tests/loaders/test_cb.py

@@ -23,6 +23,8 @@ def mock_cbc_sdk(monkeypatch: pytest.MonkeyPatch) -> Iterator[MagicMock]:
         # function that is running.
         if "dissect.target.loaders.cb" in sys.modules:
             m.delitem(sys.modules, "dissect.target.loaders.cb")
+        if "dissect.target.filesystems.cb" in sys.modules:
+            m.delitem(sys.modules, "dissect.target.filesystems.cb")
 
         mock_cbc_sdk = MagicMock()
         m.setitem(sys.modules, "cbc_sdk", mock_cbc_sdk)

{dissect_target-3.23.dev63 → dissect_target-3.23.dev65}/tests/loaders/test_smb.py

@@ -18,6 +18,8 @@ def mock_impacket(monkeypatch: pytest.MonkeyPatch) -> Iterator[MagicMock]:
     with monkeypatch.context() as m:
         if "dissect.target.loaders.smb" in sys.modules:
             m.delitem(sys.modules, "dissect.target.loaders.smb")
+        if "dissect.target.filesystems.smb" in sys.modules:
+            m.delitem(sys.modules, "dissect.target.filesystems.smb")
 
         mock_impacket = MagicMock()
         m.setitem(sys.modules, "impacket", mock_impacket)

dissect_target-3.23.dev63/dissect/target/helpers/lazy.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import importlib
-from typing import Any
-
-
-class LazyImport:
-    def __init__(self, module_name: str):
-        self._module_name = module_name
-        self._module = None
-
-    def __repr__(self) -> str:
-        return (
-            f"<lazy {self._module_name} loaded={self._module is not None} "
-            f"failed={isinstance(self._module, FailedImport)}>"
-        )
-
-    def __getattr__(self, attr: str) -> LazyAttr:
-        return LazyAttr(attr, self)
-
-    def _import(self) -> None:
-        if not self._module:
-            try:
-                self._module = importlib.import_module(self._module_name)
-            except Exception as e:
-                self._module = FailedImport(e, self)
-
-
-class FailedImport:
-    def __init__(self, exc: Exception, module: LazyImport):
-        self.exc = exc
-        self.module = module
-
-    def __getattr__(self, attr: str) -> None:
-        self._error()
-
-    def __call__(self, *args, **kwargs) -> None:
-        self._error()
-
-    def _error(self) -> None:
-        raise ImportError(f"Failed to lazily import {self.module._module_name}: {self.exc}")
-
-
-class LazyAttr:
-    def __init__(self, attr: str, module: LazyImport):
-        self.attr = attr
-        self.module = module
-        self._realattr = None
-
-    def __repr__(self) -> str:
-        return f"<lazyattr {self.module._module_name}.{self.attr} loaded={self.realattr is not None}>"
-
-    @property
-    def __doc__(self) -> str:
-        return self.realattr.__doc__
-
-    def __getattr__(self, attr: str) -> Any:
-        return getattr(self.realattr, attr)
-
-    def __call__(self, *args, **kwargs) -> Any:
-        return self.realattr(*args, **kwargs)
-
-    @property
-    def realattr(self) -> Any:
-        if not self._realattr:
-            self.module._import()
-            self._realattr = getattr(self.module._module, self.attr)
-
-        return self._realattr
-
-
-def import_lazy(module_name: str) -> LazyImport:
-    return LazyImport(module_name)