openhound 0.1.3.dev2__tar.gz → 0.1.4__tar.gz

{openhound-0.1.3.dev2 → openhound-0.1.4}/.github/workflows/test.yml

@@ -59,3 +59,11 @@ jobs:
       - name: Run BHE job scheduling test
         run: |
           .venv/bin/pytest tests/test_bhe_job_scheduling.py -v
+
+      - name: Run preprocess lookup generation tests
+        run: |
+          .venv/bin/pytest tests/test_preproc.py -v
+
+      - name: Run DuckDB lookup exception handling tests
+        run: |
+          .venv/bin/pytest tests/test_lookup.py -v

{openhound-0.1.3.dev2 → openhound-0.1.4}/PKG-INFO

@@ -1,32 +1,33 @@
 Metadata-Version: 2.4
 Name: openhound
-Version: 0.1.3.dev2
+Version: 0.1.4
 Summary: OpenGraph collector framework for BloodHound
 License-File: LICENSE.md
 Requires-Python: >=3.13
 Requires-Dist: alive-progress>=3.3.0
 Requires-Dist: cookiecutter>=2.6.0
-Requires-Dist: dlt==1.22.2
-Requires-Dist: duckdb==1.5.0
+Requires-Dist: dlt==1.26.0
+Requires-Dist: duckdb==1.5.2
 Requires-Dist: griffe-fieldz>=0.5.0
 Requires-Dist: griffe>=1.15.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: mkdocstrings[python]>=1.0.0
 Requires-Dist: psutil>=7.2.1
-Requires-Dist: pydantic-extra-types>=2.11.0
-Requires-Dist: pydantic==2.12.5
+Requires-Dist: pydantic-extra-types>=2.11.1
+Requires-Dist: pydantic==2.13.3
 Requires-Dist: tqdm>=4.67.1
-Requires-Dist: typer>=0.19.2
+Requires-Dist: typer>=0.25.1
+Requires-Dist: types-requests==2.33.0.20260503
 Provides-Extra: all
 Requires-Dist: openhound-github==0.1.0; extra == 'all'
-Requires-Dist: openhound-jamf==0.1.0; extra == 'all'
-Requires-Dist: openhound-okta==0.1.1; extra == 'all'
+Requires-Dist: openhound-jamf==0.1.3; extra == 'all'
+Requires-Dist: openhound-okta==0.1.2; extra == 'all'
 Provides-Extra: github
 Requires-Dist: openhound-github==0.1.0; extra == 'github'
 Provides-Extra: jamf
-Requires-Dist: openhound-jamf==0.1.0; extra == 'jamf'
+Requires-Dist: openhound-jamf==0.1.3; extra == 'jamf'
 Provides-Extra: okta
-Requires-Dist: openhound-okta==0.1.1; extra == 'okta'
+Requires-Dist: openhound-okta==0.1.2; extra == 'okta'
 Description-Content-Type: text/markdown
 
 <p align="center">

{openhound-0.1.3.dev2 → openhound-0.1.4}/pyproject.toml

@@ -6,35 +6,36 @@ readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "alive-progress>=3.3.0",
-    "dlt==1.22.2",
-    "duckdb==1.5.0",
+    "dlt==1.26.0",
+    "duckdb==1.5.2",
     "griffe>=1.15.0",
     "griffe-fieldz>=0.5.0",
     "mkdocstrings[python]>=1.0.0",
     "psutil>=7.2.1",
-    "pydantic==2.12.5",
+    "pydantic==2.13.3",
     "tqdm>=4.67.1",
-    "typer>=0.19.2",
+    "typer>=0.25.1",
     "cookiecutter>=2.6.0",
-    "pydantic-extra-types>=2.11.0",
     "jinja2>=3.1.6",
+    "types-requests==2.33.0.20260503",
+    "pydantic-extra-types>=2.11.1",
 ]
 
 [project.optional-dependencies]
 all = [
-    "openhound-jamf==0.1.0",
+    "openhound-jamf==0.1.3",
     "openhound-github==0.1.0",
-    "openhound-okta==0.1.1",
+    "openhound-okta==0.1.2",
 ]
 jamf = [
-    "openhound-jamf==0.1.0",
+    "openhound-jamf==0.1.3",
 ]
 github = [
     "openhound-github==0.1.0"
 ]
 
 okta = [
-    "openhound-okta==0.1.1",
+    "openhound-okta==0.1.2",
 ]
 
 [project.scripts]
@@ -66,13 +67,13 @@ local_scheme = "no-local-version"
 [dependency-groups]
 dev = [
     "openhound-faker==0.0.6",
-    "ipython>=9.12.0",
+    "ipython>=9.13.0",
     "pre-commit>=4.5.1",
     "pytest>=9.0.1",
-    "marimo>=0.23.0",
-    "altair>=6.0.0",
-    "fastapi>=0.129.0",
-    "zensical>=0.0.23",
+    "marimo>=0.23.5",
+    "altair>=6.1.0",
+    "fastapi>=0.136.1",
+    "zensical>=0.0.40",
     "ruff>=0.15.4",
     "mypy>=1.19.1",
     "types-pyyaml>=6.0.12.20250915",

openhound-0.1.4/src/openhound/core/lookup.py

@@ -0,0 +1,56 @@
+import logging
+
+import duckdb
+from duckdb import DuckDBPyConnection
+
+logger = logging.getLogger(__name__)
+
+
+class LookupManager:
+    def __init__(self, client: DuckDBPyConnection, schema: str):
+        """Create a DuckDB lookup helper bound to specific schema.
+
+        Args:
+            client (DuckDBPyConnection): DuckDB connection used for queries.
+            schema (str): Schema name containing lookup tables.
+        """
+        self.schema = schema
+        self.client = client
+
+    def _find_all_objects(self, *args) -> list:
+        """Execute a query and return all rows.
+
+        Returns:
+            list: Query result rows as a list of tuples.
+        """
+        try:
+            self.client.execute(*args)
+            results = self.client.fetchall()
+            return results
+
+        except duckdb.CatalogException as err:
+            logger.error("DuckDB lookup failed, missing table: %s", err)
+            return []
+
+        except duckdb.Error as err:
+            logger.error("DuckDB lookup query failed: %s", err)
+            return []
+
+    def _find_single_object(self, *args) -> str | None:
+        """Execute a query and return the ID of the matching row
+
+        Returns:
+            str | None: The first column (ie. ID) value as a string or None if no result is found
+        """
+        try:
+            self.client.execute(*args)
+            result = self.client.fetchone()
+            return str(result[0]) if result else None
+
+        except duckdb.CatalogException as err:
+            logger.error("DuckDB lookup failed, missing table: %s", err)
+            return None
+
+        except duckdb.Error as err:
+            logger.error("DuckDB lookup query failed: %s", err)
+            return None

{openhound-0.1.3.dev2 → openhound-0.1.4}/src/openhound/core/preproc.py

@@ -1,3 +1,4 @@
+import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Callable
@@ -12,6 +13,33 @@ from openhound.core.pipeline import BasePipeline
 from openhound.core.progress import Progress
 from openhound.sources.resource_files.source import resource_files
 
+logger = logging.getLogger(__name__)
+
+
+def run_transform(
+    transform: Callable[..., None],
+    con: duckdb.DuckDBPyConnection,
+    *args,
+    **kwargs,
+) -> None:
+    """A transformer helper function that handles DuckDB exceptions when generating a lookup"""
+    try:
+        transform(con, *args, **kwargs)
+
+    except duckdb.CatalogException as err:
+        logger.error(
+            "DuckDB preprocessing transform '%s' failed due to missing table: %s",
+            transform.__name__,
+            err,
+        )
+
+    except duckdb.Error as err:
+        logger.error(
+            "DuckDB preprocessing transform '%s' failed: %s",
+            transform.__name__,
+            err,
+        )
+
 
 class PreProcessor(BasePipeline):
     def __init__(
@@ -66,6 +94,12 @@ class PreProcessor(BasePipeline):
             con = duckdb.connect(str(self.output_file))
             try:
                 self.transformer(con)
+            except duckdb.CatalogException as err:
+                logger.error(
+                    "DuckDB preprocessing failed due to missing table: %s", err
+                )
+            except duckdb.Error as err:
+                logger.error("DuckDB preprocessing failed: %s", err)
             finally:
                 con.close()
 

openhound-0.1.4/tests/test_lookup.py

@@ -0,0 +1,41 @@
+import logging
+
+import duckdb
+
+from openhound.core.lookup import LookupManager
+
+
+def test_find_single_object_returns_none_on_duckdb_error(caplog):
+    client = duckdb.connect(":memory:")
+    lookup = LookupManager(client, "main")
+    caplog.set_level(logging.ERROR, logger="openhound.core.lookup")
+
+    try:
+        result = lookup._find_single_object("SELECT id FROM missing_table")
+    finally:
+        client.close()
+
+    assert result is None
+    assert any(
+        "DuckDB lookup failed, missing table:" in record.message
+        and "missing_table" in record.message
+        for record in caplog.records
+    )
+
+
+def test_find_all_objects_returns_empty_list_on_duckdb_error(caplog):
+    client = duckdb.connect(":memory:")
+    lookup = LookupManager(client, "main")
+    caplog.set_level(logging.ERROR, logger="openhound.core.lookup")
+
+    try:
+        result = lookup._find_all_objects("SELECT id FROM missing_table")
+    finally:
+        client.close()
+
+    assert result == []
+    assert any(
+        "DuckDB lookup failed, missing table:" in record.message
+        and "missing_table" in record.message
+        for record in caplog.records
+    )

openhound-0.1.4/tests/test_preproc.py

@@ -0,0 +1,93 @@
+import logging
+import os
+from pathlib import Path
+
+import duckdb
+
+os.environ["RUNTIME__LOG_PATH"] = "/tmp/openhound-test-logs"
+
+from openhound.core.app import DEFAULT_LOOKUP_FILE, OpenHound
+from openhound.core.preproc import PreProcessor, run_transform
+from openhound.core.progress import Progress
+
+
+def test_preproc_uses_default_lookup_file(monkeypatch, tmp_path):
+    captured: dict[str, Path] = {}
+
+    def fake_run(self, resources, filters=None):
+        captured["output_file"] = self.output_file
+        captured["resources"] = resources
+        return "ok"
+
+    monkeypatch.setattr(PreProcessor, "run", fake_run)
+
+    app = OpenHound("test", "test")
+
+    @app.preproc()
+    def preprocess(ctx):
+        return {"resource": "resource"}
+
+    result = app.preprocessor(  # type: ignore[misc]
+        input_path=tmp_path,
+        progress=Progress.log,
+    )
+
+    assert result == "ok"
+    assert captured["output_file"] == DEFAULT_LOOKUP_FILE
+    assert captured["resources"] == {"resource": "resource"}
+
+
+def test_preproc_logs_duckdb_transform_errors(monkeypatch, tmp_path, caplog):
+    def fake_run(self, source, **kwargs):
+        return "ok"
+
+    def missing_table_transform(con: duckdb.DuckDBPyConnection):
+        con.execute("SELECT * FROM missing_table")
+
+    monkeypatch.setattr(PreProcessor, "_run", fake_run)
+    caplog.set_level(logging.ERROR, logger="openhound.core.preproc")
+
+    preprocessor = PreProcessor(
+        name="test",
+        input_path=tmp_path,
+        output_file=tmp_path / "lookup.duckdb",
+        transformer=missing_table_transform,
+    )
+
+    result = preprocessor.run(resources={"resource": "resource"})
+
+    assert result == "ok"
+    assert any(
+        "DuckDB preprocessing failed due to missing table:" in record.message
+        and "missing_table" in record.message
+        for record in caplog.records
+    )
+
+
+def test_run_transform_logs_transform_name_and_continues(caplog):
+    called: list[str] = []
+
+    def missing_table_transform(con: duckdb.DuckDBPyConnection):
+        called.append("missing")
+        con.execute("SELECT * FROM missing_table")
+
+    def successful_transform(con: duckdb.DuckDBPyConnection):
+        called.append("successful")
+        con.execute("SELECT 1")
+
+    con = duckdb.connect(":memory:")
+    caplog.set_level(logging.ERROR, logger="openhound.core.preproc")
+
+    try:
+        run_transform(missing_table_transform, con)
+        run_transform(successful_transform, con)
+    finally:
+        con.close()
+
+    assert called == ["missing", "successful"]
+    assert any(
+        "DuckDB preprocessing transform 'missing_table_transform' failed due to missing table:"
+        in record.message
+        and "missing_table" in record.message
+        for record in caplog.records
+    )