habit-hooks-python 1.2.0__tar.gz → 1.3.0__tar.gz

{habit_hooks_python-1.2.0 → habit_hooks_python-1.3.0}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.5
 Name: habit-hooks-python
-Version: 1.2.0
+Version: 1.3.0
 Summary: The Python Habit Hooks plugin
 Requires-Python: >=3.11

{habit_hooks_python-1.2.0 → habit_hooks_python-1.3.0}/docs/python-plugin.spec.md

@@ -252,19 +252,50 @@ habit-sensors --all | jq '.[] | {smell, language, key: .issues[0].key, file: .is
 }
 ```
 
+## A project with no pyproject.toml or requirements.txt runs clean
+
+deptry needs a dependency declaration to check against — a `pyproject.toml`
+carrying `[project]`/`[tool.poetry.dependencies]`/`[tool.pdm]`, or one of its
+requirements filenames. A project with neither has nothing to check, and that
+is not the same as a crash: the sensor reports a clean, empty run instead of
+the `incomplete-run` the case below reports for a genuine one.
+
+📄.habit-hooks/config.toml
+```toml
+plugins = ["python"]
+
+[sensors.ruff]
+disabled = true
+```
+
+📄app.py
+```python
+def fetch(url):
+    return url
+```
+
+```bash
+habit-sensors --all
+```
+
+🖥️ ✅
+```json
+[]
+```
+
 ## A crashing deptry fails the run, never reports clean
 
-deptry needs a `pyproject.toml` to analyse; without one it exits non-zero
-instead of emitting findings. The sensor must surface that as a failure — a
-crashed tool is never a clean run. The sensor exits with a code outside the
-findings range, so `habit-sensors` raises, names the sensor on stderr, and exits
-1 rather than printing an empty (false-clean) result. The failed run carries only
-the reserved `incomplete-run` marker on stdout
+A `[tool.deptry]` option deptry does not recognise is a genuine crash — unlike
+the case above, this is not deptry answering "nothing here to check" but the
+tool itself breaking. The sensor must surface that as a failure — a broken
+tool is never a clean run. The sensor exits with a code outside the findings
+range, so `habit-sensors` raises, names the sensor on stderr, and exits 1
+rather than printing an empty (false-clean) result. The failed run carries
+only the reserved `incomplete-run` marker on stdout
 ([habit-sensors.spec.md](../../../docs/habit-sensors.spec.md)).
 
 The notice carries deptry's own diagnosis after that first line. That text is
-deptry's to word and names absolute paths, so only the line naming the sensor is
-asserted here.
+deptry's to word, so only the line naming the sensor is asserted here.
 
 📄.habit-hooks/config.toml
 ```toml
@@ -274,6 +305,16 @@ plugins = ["python"]
 disabled = true
 ```
 
+📄pyproject.toml
+```toml
+[project]
+name = "demo"
+version = "0.0.0"
+
+[tool.deptry]
+not_a_real_option = true
+```
+
 📄app.py
 ```python
 def fetch(url):

{habit_hooks_python-1.2.0 → habit_hooks_python-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "habit-hooks-python"
-version = "1.2.0"
+version = "1.3.0"
 description = "The Python Habit Hooks plugin"
 requires-python = ">=3.11"
 dependencies = []

{habit_hooks_python-1.2.0 → habit_hooks_python-1.3.0}/src/habit_hooks_python/sensors/deptry_sensor.py

@@ -37,6 +37,20 @@ def deptry_crashed(result: subprocess.CompletedProcess[str], report: Path) -> bo
     return result.returncode not in (0, 1) or not report.is_file()
 
 
+def deptry_found_no_declaration(result: subprocess.CompletedProcess[str]) -> bool:
+    """Whether deptry crashed because it found no dependency declaration to check.
+
+    deptry raises ``DependencySpecificationNotFoundError`` when it finds no
+    dependency declaration to check. Asking the tool this way, instead of
+    reimplementing its PEP 621/poetry/pdm search, keeps the answer from
+    drifting off deptry's own. A project with none declared genuinely has
+    zero declared-but-unused dependencies — a clean result, not a swallowed
+    failure (#88). Matching on the exception's class name, only inside the
+    already-crashed branch, keeps every other crash failing loud.
+    """
+    return "DependencySpecificationNotFoundError" in result.stderr
+
+
 def unused_dependencies(report: Path) -> list[dict]:
     entries = json.loads(report.read_text())
     return [entry for entry in entries if entry["error"]["code"] == "DEP002"]
@@ -71,6 +85,9 @@ def main() -> int:
         report = Path(tmp) / "deptry-report.json"
         result = run_deptry(report)
         if deptry_crashed(result, report):
+            if deptry_found_no_declaration(result):
+                print(json.dumps([]))
+                return 0
             sys.stderr.write(result.stderr)
             return 2
         print(json.dumps(findings(unused_dependencies(report))))

habit_hooks_python-1.3.0/tests/test_a_project_declaring_no_dependencies_is_clean.py

@@ -0,0 +1,75 @@
+"""A project that declares no dependencies has none that go unused.
+
+deptry raises ``DependencySpecificationNotFoundError`` when it finds no
+``pyproject.toml`` carrying a ``[project]``/``[tool.poetry.dependencies]``/
+``[tool.pdm]`` section and none of its requirements filenames either — its own
+search across PEP 621, poetry, pdm and deptry's configurable requirements
+names, in one place, so this sensor recognises that answer rather than
+re-implementing the search (see "A wrapped tool's own config wins" in
+CLAUDE.md). A project with nothing declared has, honestly, zero declared but
+unused dependencies, and that must read as a clean run, not a broken one —
+kept distinct here from every other way deptry can fail, which still has to
+fail loud (#88).
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+SENSOR = (
+    Path(__file__).resolve().parents[1]
+    / "src/habit_hooks_python/sensors/deptry_sensor.py"
+)
+
+
+def test_a_project_declaring_no_dependencies_is_a_clean_run(tmp_path: Path) -> None:
+    (tmp_path / "app.py").write_text("import os\n")
+
+    result = subprocess.run(
+        [sys.executable, str(SENSOR)],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == "[]"
+    assert result.stderr.strip() == ""
+
+
+def test_deptry_still_answers_a_missing_declaration_with_that_error(
+    tmp_path: Path,
+) -> None:
+    """The sensor recognises deptry's exception by name, so a deptry that stops
+    raising it must fail here rather than silently retire that branch."""
+    (tmp_path / "app.py").write_text("import os\n")
+
+    result = subprocess.run(
+        ["deptry", "."],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+    )
+
+    assert "DependencySpecificationNotFoundError" in result.stderr
+
+
+def test_deptry_failing_another_way_still_fails_the_run(tmp_path: Path) -> None:
+    (tmp_path / "pyproject.toml").write_text(
+        '[project]\nname = "demo"\nversion = "0.0.0"\ndependencies = []\n\n'
+        "[tool.deptry]\nnot_a_real_option = true\n"
+    )
+    (tmp_path / "app.py").write_text("import os\n")
+
+    result = subprocess.run(
+        [sys.executable, str(SENSOR)],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 2
+    assert result.stdout.strip() == ""
+    assert "not_a_real_option" in result.stderr