dirsql 0.3.14__tar.gz → 0.3.16__tar.gz

{dirsql-0.3.14 → dirsql-0.3.16}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.14"
+version = "0.3.16"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.14 → dirsql-0.3.16}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.14
+Version: 0.3.16
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'
 Requires-Dist: pytest-cov>=5 ; extra == 'dev'
 Requires-Dist: ruff>=0.4 ; extra == 'dev'
 Requires-Dist: maturin>=1.0 ; extra == 'dev'
+Requires-Dist: ty==0.0.42 ; extra == 'dev'
 Provides-Extra: dev
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.3.14 → dirsql-0.3.16}/dirsql/_async.py

@@ -104,14 +104,14 @@ class DirSQL:
 
     async def query(self, sql):
         """Execute a SQL query asynchronously."""
-        return await asyncio.to_thread(self._db.query, sql)
+        return await asyncio.to_thread(self._db.query, sql)  # ty:ignore[unresolved-attribute]
 
     def watch(self):
         """Start watching for file changes. Returns an async iterable of RowEvent."""
         return _WatchStream(self._db)
 
     @property
-    def __dict__(self):
+    def __dict__(self):  # ty:ignore[missing-override-decorator]
         """Resolved construction state as a JSON-serializable dict.
 
         Recomputed on each access; reads the ``.dirsql.toml`` if ``config=``

dirsql-0.3.16/dirsql/_dirsql.pyi

@@ -0,0 +1,63 @@
+"""Type stubs for the native PyO3 extension module.
+
+Mirrors the surface defined in ``packages/python/src/lib.rs``. Hand-written
+because pyo3-stub-gen would otherwise demand a build-time hook that the
+maturin / putitoutthere release pipeline does not yet run.
+
+Whenever ``src/lib.rs`` adds, renames, or removes a ``#[pyclass]``,
+``#[pymethods]``, or module-level binding, this file MUST be updated in the
+same PR -- and ``PARITY.md`` is the canonical reminder.
+"""
+
+from collections.abc import Callable
+from os import PathLike
+from typing import Any
+
+__version__: str
+
+Row = dict[str, Any]
+
+class Table:
+    """A table definition. Construct via keyword arguments only."""
+
+    ddl: str
+    glob: str
+    strict: bool
+
+    def __init__(
+        self,
+        *,
+        ddl: str,
+        glob: str,
+        extract: Callable[[str], list[Row]],
+        strict: bool = False,
+    ) -> None: ...
+
+class RowEvent:
+    """A row event produced by the watch loop."""
+
+    table: str | None
+    action: str
+    row: Row | None
+    old_row: Row | None
+    error: str | None
+    file_path: str | None
+
+    def __repr__(self) -> str: ...  # ty:ignore[missing-override-decorator]
+
+class DirSQL:
+    """Synchronous binding class. ``dirsql._async.DirSQL`` wraps it."""
+
+    def __init__(
+        self,
+        root: str | None = None,
+        *,
+        tables: list[Table] | None = None,
+        ignore: list[str] | None = None,
+        config: str | None = None,
+        persist: bool = False,
+        persist_path: str | PathLike[str] | None = None,
+    ) -> None: ...
+    def query(self, sql: str) -> list[Row]: ...
+    def _start_watcher(self) -> None: ...
+    def _poll_events(self, timeout_ms: int) -> list[RowEvent]: ...

dirsql-0.3.16/dirsql/cli/binary_path_test.py

@@ -0,0 +1,51 @@
+"""Unit tests for `binary_path`."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from dirsql.cli import binary_path as bp_module
+from dirsql.cli.binary_path import binary_path
+
+
+def _stage_binary(root: Path, name: str) -> Path:
+    binary_dir = root / "_binary"
+    binary_dir.mkdir()
+    target = binary_dir / name
+    target.write_text("")
+    return target
+
+
+def describe_binary_path():
+    def it_returns_the_dirsql_path_on_posix(tmp_path: Path):
+        target = _stage_binary(tmp_path, "dirsql")
+        with (
+            patch.object(bp_module, "is_windows", return_value=False),
+            patch.object(bp_module, "files", return_value=tmp_path),
+        ):
+            assert binary_path() == str(target)
+
+    def it_returns_the_dirsql_exe_path_on_windows(tmp_path: Path):
+        target = _stage_binary(tmp_path, "dirsql.exe")
+        with (
+            patch.object(bp_module, "is_windows", return_value=True),
+            patch.object(bp_module, "files", return_value=tmp_path),
+        ):
+            assert binary_path() == str(target)
+
+    def it_raises_file_not_found_when_the_posix_binary_is_missing(tmp_path: Path):
+        with (
+            patch.object(bp_module, "is_windows", return_value=False),
+            patch.object(bp_module, "files", return_value=tmp_path),
+            pytest.raises(FileNotFoundError, match="bundled `dirsql` not found"),
+        ):
+            binary_path()
+
+    def it_raises_file_not_found_when_the_windows_binary_is_missing(tmp_path: Path):
+        with (
+            patch.object(bp_module, "is_windows", return_value=True),
+            patch.object(bp_module, "files", return_value=tmp_path),
+            pytest.raises(FileNotFoundError, match="bundled `dirsql.exe` not found"),
+        ):
+            binary_path()

dirsql-0.3.16/dirsql/cli/is_windows.py

@@ -0,0 +1,9 @@
+"""Platform check used by the launcher."""
+
+from __future__ import annotations
+
+import os
+
+
+def is_windows() -> bool:
+    return os.name == "nt"

dirsql-0.3.16/dirsql/cli/is_windows_test.py

@@ -0,0 +1,20 @@
+"""Unit tests for `is_windows`."""
+
+import os
+from unittest.mock import patch
+
+from dirsql.cli.is_windows import is_windows
+
+
+def describe_is_windows():
+    def it_returns_true_when_os_name_is_nt():
+        with patch.object(os, "name", "nt"):
+            assert is_windows() is True
+
+    def it_returns_false_when_os_name_is_posix():
+        with patch.object(os, "name", "posix"):
+            assert is_windows() is False
+
+    def it_returns_false_when_os_name_is_anything_else():
+        with patch.object(os, "name", "java"):
+            assert is_windows() is False

{dirsql-0.3.14 → dirsql-0.3.16}/dirsql/cli/main.py

@@ -24,4 +24,4 @@ def main(argv: list[str] | None = None) -> int:
         completed = subprocess.run([binary, *argv])
         return completed.returncode
     os.execv(binary, [binary, *argv])
-    return 0  # unreachable
+    return 0

dirsql-0.3.16/dirsql/cli/main_test.py

@@ -0,0 +1,87 @@
+"""Unit tests for the launcher's `main`."""
+
+import io
+import os
+import subprocess
+import sys
+from unittest.mock import patch
+
+from dirsql.cli import main as main_module
+from dirsql.cli.main import main
+
+
+class _Completed:
+    def __init__(self, returncode: int):
+        self.returncode = returncode
+
+
+def describe_main():
+    def describe_when_binary_path_raises_file_not_found():
+        def it_returns_1_and_writes_a_dirsql_prefixed_message_to_stderr():
+            fake_stderr = io.StringIO()
+            with (
+                patch.object(
+                    main_module,
+                    "binary_path",
+                    side_effect=FileNotFoundError("bundled `dirsql` missing"),
+                ),
+                patch.object(sys, "stderr", fake_stderr),
+            ):
+                assert main([]) == 1
+            assert fake_stderr.getvalue() == "dirsql: bundled `dirsql` missing\n"
+
+    def describe_on_windows():
+        def it_runs_the_binary_via_subprocess_and_returns_its_returncode():
+            with (
+                patch.object(main_module, "binary_path", return_value="C:/dirsql.exe"),
+                patch.object(main_module, "is_windows", return_value=True),
+                patch.object(subprocess, "run", return_value=_Completed(7)) as run,
+            ):
+                assert main(["--version"]) == 7
+            run.assert_called_once_with(["C:/dirsql.exe", "--version"])
+
+        def it_does_not_invoke_execv():
+            with (
+                patch.object(main_module, "binary_path", return_value="C:/dirsql.exe"),
+                patch.object(main_module, "is_windows", return_value=True),
+                patch.object(subprocess, "run", return_value=_Completed(0)),
+                patch.object(os, "execv") as execv,
+            ):
+                main([])
+            execv.assert_not_called()
+
+    def describe_on_posix():
+        def it_hands_off_to_execv_with_the_binary_argv_pair():
+            with (
+                patch.object(
+                    main_module, "binary_path", return_value="/usr/local/bin/dirsql"
+                ),
+                patch.object(main_module, "is_windows", return_value=False),
+                patch.object(os, "execv") as execv,
+            ):
+                main(["query", "select 1"])
+            execv.assert_called_once_with(
+                "/usr/local/bin/dirsql",
+                ["/usr/local/bin/dirsql", "query", "select 1"],
+            )
+
+        def it_returns_0_when_execv_returns():
+            # In production `os.execv` never returns. The mock returns,
+            # so `main` falls through to `return 0`.
+            with (
+                patch.object(main_module, "binary_path", return_value="/bin/dirsql"),
+                patch.object(main_module, "is_windows", return_value=False),
+                patch.object(os, "execv"),
+            ):
+                assert main([]) == 0
+
+    def describe_when_argv_is_none():
+        def it_pulls_from_sys_argv_skipping_the_program_name():
+            with (
+                patch.object(sys, "argv", ["dirsql", "--help"]),
+                patch.object(main_module, "binary_path", return_value="C:/dirsql.exe"),
+                patch.object(main_module, "is_windows", return_value=True),
+                patch.object(subprocess, "run", return_value=_Completed(0)) as run,
+            ):
+                main(argv=None)
+            run.assert_called_once_with(["C:/dirsql.exe", "--help"])

{dirsql-0.3.14 → dirsql-0.3.16}/dirsql/resolve_config.py

@@ -20,7 +20,7 @@ def resolve_config(root, tables, ignore, config, persist, persist_path):
         cfg_dir = os.path.dirname(os.path.abspath(config))
 
     def _abs(p):
-        return p if os.path.isabs(p) else os.path.join(cfg_dir, p)
+        return p if os.path.isabs(p) else os.path.join(cfg_dir, p)  # ty:ignore[no-matching-overload]
 
     return {
         "root": root or (_abs(cfg["root"]) if "root" in cfg else cfg_dir),

{dirsql-0.3.14 → dirsql-0.3.16}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.14"
+version = "0.3.16"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.14 → dirsql-0.3.16}/pyproject.toml

@@ -27,6 +27,8 @@ dev = [
     "pytest-cov>=5",
     "ruff>=0.4",
     "maturin>=1.0",
+    # ty is pre-1.0 -- pin tightly. Re-pin in lockstep with CI.
+    "ty==0.0.42",
 ]
 
 [project.scripts]
@@ -57,22 +59,40 @@ include = [
 ]
 manifest-path = "packages/python/Cargo.toml"
 
-# CLI launcher shims (`cli/main.py`, `cli/binary_path.py`,
-# `cli/is_windows.py`) that locate and exec the bundled Rust binary --
-# the Python analogue of the excluded `src/bin/` Rust launcher. The
-# AGENTS.md test-boundary rules forbid monkeypatch unit tests on
-# production module attributes (`os.execv`, `binary_path`, etc.) -- the
-# load-bearing line is the `os.execv` hand-off, whose only meaningful
-# coverage is end-to-end (real wheel install + `dirsql --version`),
-# verified by putitoutthere's wheel-content guard post-build. Omitting
-# these files keeps the 100% coverage floor honest about library code.
+# Type checking. Migration model: existing untyped code is frozen behind
+# `# ty: ignore[...]` baseline comments inserted by `ty check --add-ignore`;
+# any new error in new or touched code fails CI. Every rule is promoted to
+# `"error"`, matching TypeScript-strict discipline. Test files are excluded
+# because they monkeypatch fakes onto production module attributes
+# (`monkeypatch.setattr(async_mod, "_RustDirSQL", ...)`) -- AGENTS.md flags
+# that as a smell, ty surfaces it accurately, and the cleanup (constructor
+# injection) is tracked separately.
+[tool.ty.src]
+exclude = [
+    "**/test_*.py",
+    "**/*_test.py",
+    "tests/",
+    "build/",
+    "dirsql/_binary/",
+]
+
+[tool.ty.environment]
+python-version = "3.11"
+
+# Ruff enforces "every type-ignore must cite a rule code" (PGH003) so a
+# `# type: ignore` or `# ty: ignore` without `[...]` fails lint. Stops the
+# escape hatch from quietly widening.
+[tool.ruff.lint]
+extend-select = ["PGH003"]
+
 [tool.coverage.run]
 omit = [
-    "dirsql/cli/*",
     # Colocated unit tests live alongside the package source; instrumenting
     # them lets a test double's own branches pad the metric (e.g. a fake's
     # empty-list return). Exclude test files so the floor reflects only
     # library code.
     "dirsql/test_*.py",
     "dirsql/*_test.py",
+    "dirsql/cli/test_*.py",
+    "dirsql/cli/*_test.py",
 ]

dirsql-0.3.14/dirsql/cli/is_windows.py

@@ -1,10 +0,0 @@
-"""Platform check used by the launcher. Isolated so tests can override it
-without mutating the ``os.name`` global (which upsets pathlib)."""
-
-from __future__ import annotations
-
-import os
-
-
-def is_windows() -> bool:
-    return os.name == "nt"