dirsql 0.3.41__tar.gz → 0.3.42__tar.gz

{dirsql-0.3.41 → dirsql-0.3.42}/Cargo.lock

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

{dirsql-0.3.41 → dirsql-0.3.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.41
+Version: 0.3.42
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.3.41 → dirsql-0.3.42}/dirsql/_async.py

@@ -1,20 +1,8 @@
 """Async-by-default DirSQL wrapper."""
 
 import asyncio
-from typing import TYPE_CHECKING
 
 from dirsql._dirsql import DirSQL as _RustDirSQL
-from dirsql.resolve_config import resolve_config
-
-if TYPE_CHECKING:
-    # `typing.override` is 3.12+; the package supports 3.11, so source it from
-    # `typing_extensions` for the type checker only. At runtime `@override` is
-    # a pure marker, so a no-op identity avoids the runtime dependency.
-    from typing_extensions import override
-else:
-
-    def override(func):
-        return func
 
 
 class _WatchStream:
@@ -135,21 +123,3 @@ class DirSQL:
     def watch(self):
         """Start watching for file changes. Returns an async iterable of RowEvent."""
         return _WatchStream(self._db)
-
-    @property
-    @override
-    def __dict__(self):
-        """Resolved construction state as a JSON-serializable dict.
-
-        Recomputed on each access; reads the ``.dirsql.toml`` if ``config=``
-        was supplied. Works before ``await db.ready()``.
-        """
-        return resolve_config(
-            self._root,
-            self._tables,
-            self._ignore,
-            self._config,
-            self._persist,
-            self._persist_path,
-            self._extensions,
-        )

dirsql-0.3.42/dirsql/cli/interpret/__init__.py

@@ -0,0 +1,14 @@
+"""Empty package shell — the native-config ``interpret`` helper was removed.
+
+The ``dirsql interpret`` subcommand and its NDJSON ``extract`` loop (``run``,
+``load_app``, ``dispatch_extract``, ``write_message``) were removed in #321
+(#323). The CLI now accepts only ``.dirsql.toml``; to run user-defined
+``extract`` callbacks, use the programmatic SDK (``DirSQL(...)`` with
+in-process closures).
+
+This ``__init__.py`` carries no logic and no re-exports. It remains only
+because the colocated-test tooling cannot yet express *deleting* an exempt
+package barrel (the co-change check flags a deleted source that has no
+co-deleted colocated test, and a retained exempt for a deleted path is
+rejected as stale). The directory is removed once that is resolved.
+"""

{dirsql-0.3.41 → dirsql-0.3.42}/dirsql/cli/main.py

@@ -1,8 +1,6 @@
 """Console-script entry point. Execs the bundled binary on POSIX,
-subprocesses it on Windows. When ``argv[0] == "interpret"`` the
-in-process Python helper handles the subcommand directly so a Rust
-orchestrator can spawn this script for native-language configs (#196)
-without depending on the bundled Rust binary."""
+subprocesses it on Windows. All argv is forwarded transparently to the
+bundled Rust binary."""
 
 from __future__ import annotations
 
@@ -18,14 +16,6 @@ def main(argv: list[str] | None = None) -> int:
     if argv is None:
         argv = sys.argv[1:]
 
-    if argv and argv[0] == "interpret":
-        from .interpret.run import run
-
-        try:
-            return run(argv[1:])
-        except KeyboardInterrupt:
-            return 130
-
     try:
         binary = binary_path()
     except FileNotFoundError as exc:

{dirsql-0.3.41/packages/rust → dirsql-0.3.42}/docs/api/index.md

@@ -59,6 +59,7 @@ new DirSQL({
     tables?: TableDef[],
     ignore?: string[],
     config?: string,
+    extensions?: ExtensionSpec[],  // [{ path: string, entrypoint?: string }]
 })
 ```
 
@@ -76,7 +77,7 @@ In Python, the constructor starts scanning in a background thread and returns im
 - `tables` -- List of `Table` definitions. Each defines a SQLite table, a glob pattern, and an extract function.
 - `ignore` -- Optional list of glob patterns. Files matching any ignore pattern are skipped regardless of table globs.
 - `config` -- Optional path to a `.dirsql.toml` config file. Its `[[table]]` entries are appended to any programmatic `tables`; its `[dirsql].ignore` patterns are appended to any explicit `ignore`; its optional `[dirsql].root` supplies the root directory when `root` is not passed explicitly; its `[[dirsql.extension]]` entries are appended to any programmatic `extensions`.
-- `extensions` -- Optional SQLite extensions to load onto the connection at startup, before any table DDL (enable → load → disable, so the SQL `load_extension()` function is never left exposed). Each entry pairs a shared-library `path` with an optional `entrypoint` init-symbol override (Python: `{ "path", "entrypoint"? }` dicts; Rust: `Extension { path, entrypoint }`). Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. Available in the Python and Rust SDKs; the TypeScript constructor parameter is tracked in [#230](https://github.com/thekevinscott/dirsql/issues/230). See [Loading extensions](../cli/config.md#loading-extensions).
+- `extensions` -- Optional SQLite extensions to load onto the connection at startup, before any table DDL (enable → load → disable, so the SQL `load_extension()` function is never left exposed). Each entry pairs a shared-library `path` with an optional `entrypoint` init-symbol override (Python: `{ "path", "entrypoint"? }` dicts; Rust: `Extension { path, entrypoint }`; TypeScript: `{ path, entrypoint? }` objects). Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. Available in the Python, Rust, and TypeScript SDKs. See [Loading extensions](../cli/config.md#loading-extensions).
 
 ### Methods
 
@@ -162,7 +163,7 @@ JSON.stringify(db)  // via db.toJSON()
 
 :::
 
-Returns the resolved construction state as a JSON-compatible value with fields `root`, `tables`, `ignore`, `persist`, `persist_path` (camelCase `persistPath` in TypeScript). Each table is `{ ddl, glob, strict }`. The Python and Rust snapshots also include `extensions` -- an array of `{ path, entrypoint }` (empty when none are configured); the TypeScript `toJSON` snapshot will gain it with [#230](https://github.com/thekevinscott/dirsql/issues/230). Excludes the original `config` path (already merged into `root` / `tables` / `ignore`), per-table `extract`, and per-table `name`. Available immediately after construction in Python and TypeScript; Rust's sync `build()` returns a ready instance.
+Returns the resolved construction state as a JSON-compatible value with fields `root`, `tables`, `ignore`, `persist`, `persist_path` (camelCase `persistPath` in TypeScript). Each table is `{ ddl, glob, strict }`. All three SDK snapshots also include `extensions` -- an array of `{ path, entrypoint }` (empty when none are configured; `entrypoint` is `null` when no override was supplied). Excludes the original `config` path (already merged into `root` / `tables` / `ignore`), per-table `extract`, and per-table `name`. Available immediately after construction in Python and TypeScript; Rust's sync `build()` returns a ready instance.
 
 ---
 

{dirsql-0.3.41 → dirsql-0.3.42}/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.41"
+version = "0.3.42"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.41 → dirsql-0.3.42/packages/python}/docs/api/index.md

@@ -59,6 +59,7 @@ new DirSQL({
     tables?: TableDef[],
     ignore?: string[],
     config?: string,
+    extensions?: ExtensionSpec[],  // [{ path: string, entrypoint?: string }]
 })
 ```
 
@@ -76,7 +77,7 @@ In Python, the constructor starts scanning in a background thread and returns im
 - `tables` -- List of `Table` definitions. Each defines a SQLite table, a glob pattern, and an extract function.
 - `ignore` -- Optional list of glob patterns. Files matching any ignore pattern are skipped regardless of table globs.
 - `config` -- Optional path to a `.dirsql.toml` config file. Its `[[table]]` entries are appended to any programmatic `tables`; its `[dirsql].ignore` patterns are appended to any explicit `ignore`; its optional `[dirsql].root` supplies the root directory when `root` is not passed explicitly; its `[[dirsql.extension]]` entries are appended to any programmatic `extensions`.
-- `extensions` -- Optional SQLite extensions to load onto the connection at startup, before any table DDL (enable → load → disable, so the SQL `load_extension()` function is never left exposed). Each entry pairs a shared-library `path` with an optional `entrypoint` init-symbol override (Python: `{ "path", "entrypoint"? }` dicts; Rust: `Extension { path, entrypoint }`). Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. Available in the Python and Rust SDKs; the TypeScript constructor parameter is tracked in [#230](https://github.com/thekevinscott/dirsql/issues/230). See [Loading extensions](../cli/config.md#loading-extensions).
+- `extensions` -- Optional SQLite extensions to load onto the connection at startup, before any table DDL (enable → load → disable, so the SQL `load_extension()` function is never left exposed). Each entry pairs a shared-library `path` with an optional `entrypoint` init-symbol override (Python: `{ "path", "entrypoint"? }` dicts; Rust: `Extension { path, entrypoint }`; TypeScript: `{ path, entrypoint? }` objects). Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. Available in the Python, Rust, and TypeScript SDKs. See [Loading extensions](../cli/config.md#loading-extensions).
 
 ### Methods
 
@@ -162,7 +163,7 @@ JSON.stringify(db)  // via db.toJSON()
 
 :::
 
-Returns the resolved construction state as a JSON-compatible value with fields `root`, `tables`, `ignore`, `persist`, `persist_path` (camelCase `persistPath` in TypeScript). Each table is `{ ddl, glob, strict }`. The Python and Rust snapshots also include `extensions` -- an array of `{ path, entrypoint }` (empty when none are configured); the TypeScript `toJSON` snapshot will gain it with [#230](https://github.com/thekevinscott/dirsql/issues/230). Excludes the original `config` path (already merged into `root` / `tables` / `ignore`), per-table `extract`, and per-table `name`. Available immediately after construction in Python and TypeScript; Rust's sync `build()` returns a ready instance.
+Returns the resolved construction state as a JSON-compatible value with fields `root`, `tables`, `ignore`, `persist`, `persist_path` (camelCase `persistPath` in TypeScript). Each table is `{ ddl, glob, strict }`. All three SDK snapshots also include `extensions` -- an array of `{ path, entrypoint }` (empty when none are configured; `entrypoint` is `null` when no override was supplied). Excludes the original `config` path (already merged into `root` / `tables` / `ignore`), per-table `extract`, and per-table `name`. Available immediately after construction in Python and TypeScript; Rust's sync `build()` returns a ready instance.
 
 ---
 

{dirsql-0.3.41 → dirsql-0.3.42}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1782763249,
+  "ran_at": 1782833107,
   "exit_code": 0,
-  "commit": "8a3051871b21e04c0c2c2cc11a57e4c0a9b94866"
+  "commit": "07bd37825c22f9ad73153d70fc65c9e3c92f855e"
 }

{dirsql-0.3.41/packages/python → dirsql-0.3.42/packages/rust}/docs/api/index.md

@@ -59,6 +59,7 @@ new DirSQL({
     tables?: TableDef[],
     ignore?: string[],
     config?: string,
+    extensions?: ExtensionSpec[],  // [{ path: string, entrypoint?: string }]
 })
 ```
 
@@ -76,7 +77,7 @@ In Python, the constructor starts scanning in a background thread and returns im
 - `tables` -- List of `Table` definitions. Each defines a SQLite table, a glob pattern, and an extract function.
 - `ignore` -- Optional list of glob patterns. Files matching any ignore pattern are skipped regardless of table globs.
 - `config` -- Optional path to a `.dirsql.toml` config file. Its `[[table]]` entries are appended to any programmatic `tables`; its `[dirsql].ignore` patterns are appended to any explicit `ignore`; its optional `[dirsql].root` supplies the root directory when `root` is not passed explicitly; its `[[dirsql.extension]]` entries are appended to any programmatic `extensions`.
-- `extensions` -- Optional SQLite extensions to load onto the connection at startup, before any table DDL (enable → load → disable, so the SQL `load_extension()` function is never left exposed). Each entry pairs a shared-library `path` with an optional `entrypoint` init-symbol override (Python: `{ "path", "entrypoint"? }` dicts; Rust: `Extension { path, entrypoint }`). Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. Available in the Python and Rust SDKs; the TypeScript constructor parameter is tracked in [#230](https://github.com/thekevinscott/dirsql/issues/230). See [Loading extensions](../cli/config.md#loading-extensions).
+- `extensions` -- Optional SQLite extensions to load onto the connection at startup, before any table DDL (enable → load → disable, so the SQL `load_extension()` function is never left exposed). Each entry pairs a shared-library `path` with an optional `entrypoint` init-symbol override (Python: `{ "path", "entrypoint"? }` dicts; Rust: `Extension { path, entrypoint }`; TypeScript: `{ path, entrypoint? }` objects). Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. Available in the Python, Rust, and TypeScript SDKs. See [Loading extensions](../cli/config.md#loading-extensions).
 
 ### Methods
 
@@ -162,7 +163,7 @@ JSON.stringify(db)  // via db.toJSON()
 
 :::
 
-Returns the resolved construction state as a JSON-compatible value with fields `root`, `tables`, `ignore`, `persist`, `persist_path` (camelCase `persistPath` in TypeScript). Each table is `{ ddl, glob, strict }`. The Python and Rust snapshots also include `extensions` -- an array of `{ path, entrypoint }` (empty when none are configured); the TypeScript `toJSON` snapshot will gain it with [#230](https://github.com/thekevinscott/dirsql/issues/230). Excludes the original `config` path (already merged into `root` / `tables` / `ignore`), per-table `extract`, and per-table `name`. Available immediately after construction in Python and TypeScript; Rust's sync `build()` returns a ready instance.
+Returns the resolved construction state as a JSON-compatible value with fields `root`, `tables`, `ignore`, `persist`, `persist_path` (camelCase `persistPath` in TypeScript). Each table is `{ ddl, glob, strict }`. All three SDK snapshots also include `extensions` -- an array of `{ path, entrypoint }` (empty when none are configured; `entrypoint` is `null` when no override was supplied). Excludes the original `config` path (already merged into `root` / `tables` / `ignore`), per-table `extract`, and per-table `name`. Available immediately after construction in Python and TypeScript; Rust's sync `build()` returns a ready instance.
 
 ---
 

{dirsql-0.3.41 → dirsql-0.3.42}/pyproject.toml

@@ -98,7 +98,7 @@ omit = [
     # 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. Recursive glob so nested packages (e.g.
-    # `dirsql/cli/interpret/`) are covered too.
+    # `dirsql/cli/`) are covered too.
     "**/test_*.py",
     "**/*_test.py",
 ]

dirsql-0.3.41/dirsql/cli/interpret/__init__.py

@@ -1,17 +0,0 @@
-"""`dirsql interpret <config>` -- long-running native config helper (#196).
-
-Loads a Python config file, takes its module-level ``app = DirSQL(...)``,
-and serves ``extract`` requests over NDJSON on stdin/stdout. One line in,
-one line out, sequential.
-
-See the individual submodules for behavior:
-- ``run`` -- subcommand entry point invoked from ``dirsql.cli.main``
-- ``load_app`` -- importlib-based config loader
-- ``write_message`` -- single-line NDJSON writer
-- ``dispatch_extract`` -- per-request handler
-
-No top-level re-exports: the function is at ``.run.run``. Re-exporting
-``run`` at the package level would shadow the submodule (so
-``from . import run`` in tests would resolve to the function and break
-``patch.object(run_module, "load_app", ...)``).
-"""

dirsql-0.3.41/dirsql/cli/interpret/dispatch_extract.py

@@ -1,41 +0,0 @@
-"""Single-request handler for the `dirsql interpret` helper.
-
-Given a parsed request line and a name->table lookup, call the user's
-``extract`` callback and return the NDJSON response payload the loop
-will write back to stdout.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def dispatch_extract(
-    req: dict[str, Any],
-    tables: dict[str, Any],
-) -> dict[str, Any]:
-    """Build the `{"type": "result", ...}` response for one extract request.
-
-    - Unknown table name -> ``ok: false`` with a name-bearing error.
-    - User's ``extract`` raising -> ``ok: false`` with ``str(exc)``.
-    - Success -> ``ok: true`` with the row list the callback returned.
-
-    ``req["id"]`` is echoed back unchanged so the caller can correlate
-    request and response.
-    """
-    rid = req.get("id")
-    name = req.get("table")
-    path = req.get("path")
-    table = tables.get(name) if isinstance(name, str) else None
-    if table is None:
-        return {
-            "type": "result",
-            "id": rid,
-            "ok": False,
-            "error": f"unknown table: {name!r}",
-        }
-    try:
-        rows = table.extract(path)
-    except Exception as exc:
-        return {"type": "result", "id": rid, "ok": False, "error": str(exc)}
-    return {"type": "result", "id": rid, "ok": True, "rows": rows}

dirsql-0.3.41/dirsql/cli/interpret/load_app.py

@@ -1,32 +0,0 @@
-"""importlib-based config loader for the `dirsql interpret` helper.
-
-The user's config is a regular Python module that constructs a
-``DirSQL`` instance and assigns it to a top-level ``app`` name. We
-import it via ``importlib.util.spec_from_file_location`` so the user
-doesn't have to put their config on ``sys.path``.
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import os
-from typing import Any
-
-
-def load_app(config_path: str) -> Any:
-    """Import ``config_path`` and return its ``app`` attribute.
-
-    Raises ``ImportError`` if the file can't be loaded as a module, and
-    ``AttributeError`` if the module loads but defines no ``app``.
-    """
-    abs_path = os.path.abspath(config_path)
-    spec = importlib.util.spec_from_file_location("_dirsql_user_config", abs_path)
-    if spec is None or spec.loader is None:
-        raise ImportError(f"could not load config: {config_path}")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    if not hasattr(module, "app"):
-        raise AttributeError(
-            f"{config_path}: module must define a top-level `app = DirSQL(...)`"
-        )
-    return module.app

dirsql-0.3.41/dirsql/cli/interpret/run.py

@@ -1,85 +0,0 @@
-"""Subcommand entry point for `dirsql interpret <config>`.
-
-Glues the per-purpose helpers (`load_app`, `dispatch_extract`,
-`write_message`) into the long-running NDJSON loop:
-
-  handshake (helper -> caller, once on startup):
-    {"type": "config", "state": <vars(app)>}
-
-  extract request (caller -> helper):
-    {"type": "extract", "id": <int>, "table": "<name>", "path": "<abs>"}
-
-  extract response (helper -> caller):
-    {"type": "result", "id": <int>, "ok": true,  "rows": [...]}
-    {"type": "result", "id": <int>, "ok": false, "error": "<msg>"}
-
-Exits 0 when stdin closes; non-zero with a single ``dirsql interpret:``
-line on stderr if the config can't be loaded.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-
-from .dispatch_extract import dispatch_extract
-from .load_app import load_app
-from .write_message import write_message
-
-
-def run(argv: list[str]) -> int:
-    if len(argv) != 1:
-        sys.stderr.write(
-            f"dirsql interpret: expected one config path, got {len(argv)}\n"
-        )
-        return 1
-    config_path = argv[0]
-
-    try:
-        app = load_app(config_path)
-    except Exception as exc:
-        sys.stderr.write(f"dirsql interpret: {exc}\n")
-        return 1
-
-    # A config file describes a single DirSQL; it must not itself delegate to
-    # another `config=` path. The interpret handshake has no field for a
-    # nested config and would recurse, so reject it up front.
-    if app._config is not None:
-        sys.stderr.write(
-            "dirsql interpret: a config file cannot itself set config= "
-            "(nested config is not supported)\n"
-        )
-        return 1
-
-    # Name comes from `dirsql::db::parse_table_name` -- the canonical
-    # core parser, surfaced via PyO3 on `Table.name` (#196). No regex
-    # duplication on the Python side. Tables with a name the parser
-    # couldn't extract are skipped here; the malformed DDL would also
-    # surface as a `DirSqlError::Ddl` during the SDK scan, which
-    # `await app.ready()` would re-raise -- not interpret's job to
-    # second-guess.
-    tables = {t.name: t for t in (app._tables or []) if t.name is not None}
-
-    # When the config supplies neither `root` nor `config=`, the resolved
-    # root is None. Default it to the process cwd -- the directory the
-    # `dirsql` command was launched from, which interpret inherits from the
-    # parent binary -- so a root-less config indexes "here".
-    state = vars(app)
-    if state.get("root") is None:
-        state["root"] = os.getcwd()
-    write_message({"type": "config", "state": state})
-
-    for line in sys.stdin:
-        stripped = line.strip()
-        if not stripped:
-            continue
-        try:
-            req = json.loads(stripped)
-        except json.JSONDecodeError:
-            continue
-        if not isinstance(req, dict) or req.get("type") != "extract":
-            continue
-        write_message(dispatch_extract(req, tables))
-
-    return 0

dirsql-0.3.41/dirsql/cli/interpret/write_message.py

@@ -1,18 +0,0 @@
-"""Single-line NDJSON writer for the `dirsql interpret` helper."""
-
-from __future__ import annotations
-
-import json
-import sys
-from typing import Any
-
-
-def write_message(msg: dict[str, Any]) -> None:
-    """Write one NDJSON line to stdout and flush.
-
-    The flush is required so the orchestrator on the other side of the
-    pipe sees the message immediately; without it the buffered stream
-    would deliver lines in batches.
-    """
-    sys.stdout.write(json.dumps(msg) + "\n")
-    sys.stdout.flush()

dirsql-0.3.41/dirsql/resolve_config.py

@@ -1,61 +0,0 @@
-"""Synchronous config resolver for `DirSQL.__dict__`.
-
-Mirrors `DirSQLBuilder::resolve` in the Rust core: explicit kwargs win for
-scalars; tables and ignore lists are concatenated; persist is OR-ed;
-path-valued config fields resolve relative to the config file's parent.
-"""
-
-import os
-import tomllib
-
-
-def resolve_config(
-    root, tables, ignore, config, persist, persist_path, extensions=None
-):
-    """Merge kwargs with a `.dirsql.toml` into the serialized state shape."""
-    cfg, cfg_tables, cfg_extensions, cfg_dir = {}, [], [], None
-    if config is not None:
-        with open(config, "rb") as f:
-            doc = tomllib.load(f)
-        cfg = doc.get("dirsql") or {}
-        cfg_tables = doc.get("table") or []
-        cfg_extensions = cfg.get("extension") or []
-        cfg_dir = os.path.dirname(os.path.abspath(config))
-
-    def _abs(p):
-        # Only reached from the `"<key>" in cfg` branches below, and cfg is
-        # non-empty only after a config file was loaded -- which sets cfg_dir.
-        base = cfg_dir
-        assert base is not None
-        return p if os.path.isabs(p) else os.path.join(base, p)
-
-    return {
-        "root": root or (_abs(cfg["root"]) if "root" in cfg else cfg_dir),
-        "tables": [
-            {"ddl": t.ddl, "glob": t.glob, "strict": bool(t.strict)}
-            for t in (tables or [])
-        ]
-        + [
-            {
-                "ddl": e.get("ddl"),
-                "glob": e.get("glob"),
-                "strict": bool(e.get("strict")),
-            }
-            for e in cfg_tables
-        ],
-        "ignore": list(ignore or []) + list(cfg.get("ignore") or []),
-        "persist": bool(persist or cfg.get("persist")),
-        "persist_path": persist_path
-        or (_abs(cfg["persist_path"]) if "persist_path" in cfg else None),
-        # Programmatic extensions first (verbatim paths, mirroring the Rust
-        # builder), then config-file `[[dirsql.extension]]` entries with
-        # relative paths resolved against the config's parent directory.
-        "extensions": [
-            {"path": e["path"], "entrypoint": e.get("entrypoint")}
-            for e in (extensions or [])
-        ]
-        + [
-            {"path": _abs(e["path"]), "entrypoint": e.get("entrypoint")}
-            for e in cfg_extensions
-        ],
-    }

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/data/a/meta.json

@@ -1 +0,0 @@
-{"title": "Alpha"}

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/data/b/meta.json

@@ -1 +0,0 @@
-{"title": "Beta"}

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/dirsql.config.py

@@ -1,29 +0,0 @@
-"""A native Python config file for dirsql.
-
-When ``dirsql --config <path-to-this-file>`` runs, the Rust binary
-spawns ``dirsql interpret`` against this file. The helper loads the
-module, takes its module-level ``app``, and dispatches ``extract``
-callbacks over NDJSON.
-"""
-
-import json
-import os
-
-from dirsql import DirSQL, Table
-
-
-def _extract(path):
-    with open(path) as f:
-        return [json.load(f)]
-
-
-app = DirSQL(
-    root=os.path.join(os.path.dirname(__file__), "data"),
-    tables=[
-        Table(
-            ddl="CREATE TABLE papers (title TEXT)",
-            glob="**/meta.json",
-            extract=_extract,
-        )
-    ],
-)

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/data/a/meta.json

@@ -1 +0,0 @@
-{"title": "Alpha"}

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/data/b/meta.json

@@ -1 +0,0 @@
-{"title": "Beta"}

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/dirsql.config.py

@@ -1,27 +0,0 @@
-"""Happy-path fixture for `dirsql interpret` integration tests.
-
-Exposes a single `papers` table whose `extract` reads each `meta.json`
-under the colocated `data/` tree and returns its parsed contents.
-"""
-
-import json
-import os
-
-from dirsql import DirSQL, Table
-
-
-def _extract(path):
-    with open(path, encoding="utf-8") as f:
-        return [json.load(f)]
-
-
-app = DirSQL(
-    root=os.path.join(os.path.dirname(__file__), "data"),
-    tables=[
-        Table(
-            ddl="CREATE TABLE papers (title TEXT)",
-            glob="**/meta.json",
-            extract=_extract,
-        )
-    ],
-)

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/dirsql.config_nested.py

@@ -1,13 +0,0 @@
-"""Fixture: a native Python config that itself sets ``config=``.
-
-`dirsql interpret` must reject this -- a config file loaded by interpret
-cannot delegate to another config file (nested config loading). The
-referenced TOML is valid, so the rejection comes from the loader, not from
-a TOML read error.
-"""
-
-import os
-
-from dirsql import DirSQL
-
-app = DirSQL(config=os.path.join(os.path.dirname(__file__), "nested.dirsql.toml"))

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/dirsql.config_no_app.py

@@ -1,3 +0,0 @@
-"""Fixture without a top-level `app` -- exercises startup failure."""
-
-NOT_THE_APP = 42

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/dirsql.config_no_root.py

@@ -1,26 +0,0 @@
-"""Fixture: a native Python config that omits ``root``.
-
-`dirsql interpret` should resolve the root to the helper process's current
-working directory (the cwd the orchestrator was launched from) rather than
-erroring. Mirrors ``dirsql.config.py`` but drops the ``root=`` argument.
-"""
-
-import json
-
-from dirsql import DirSQL, Table
-
-
-def _extract(path):
-    with open(path, encoding="utf-8") as f:
-        return [json.load(f)]
-
-
-app = DirSQL(
-    tables=[
-        Table(
-            ddl="CREATE TABLE papers (title TEXT)",
-            glob="**/meta.json",
-            extract=_extract,
-        )
-    ],
-)

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/dirsql.config_raises.py

@@ -1,21 +0,0 @@
-"""Fixture whose `extract` raises -- exercises the `ok: false` response."""
-
-import os
-
-from dirsql import DirSQL, Table
-
-
-def _boom(_path):
-    raise ValueError("synthetic extract failure")
-
-
-app = DirSQL(
-    root=os.path.join(os.path.dirname(__file__), "data"),
-    tables=[
-        Table(
-            ddl="CREATE TABLE papers (title TEXT)",
-            glob="**/meta.json",
-            extract=_boom,
-        )
-    ],
-)

dirsql-0.3.41/packages/python/tests/e2e/__fixtures__/interpret/nested.dirsql.toml

@@ -1,6 +0,0 @@
-# Valid config referenced by `dirsql.config_nested.py`. Its validity is the
-# point: the interpret loader must reject the *nesting*, not fail on a bad
-# TOML read.
-[[table]]
-ddl = "CREATE TABLE papers (title TEXT)"
-glob = "**/meta.json"

dirsql-0.3.41/packages/python/tests/e2e/interpret_subprocess.py

@@ -1,96 +0,0 @@
-"""Subprocess plumbing for the `dirsql interpret` e2e tests.
-
-Kept in its own module (rather than `conftest.py` or inline in the
-test file) because these helpers are not pytest fixtures -- they are
-plain functions that drive a child process via NDJSON. Importing them
-keeps each test focused on the assertion, not the framing.
-
-Naming intentionally does not match `test_*.py` / `*_test.py` so
-pytest skips collection.
-"""
-
-from __future__ import annotations
-
-import json
-import shutil
-import subprocess
-import threading
-from pathlib import Path
-from typing import Any
-
-
-def cli_argv() -> list[str]:
-    """Resolve the `dirsql` console-script invocation for this test env.
-
-    Failing loudly here surfaces an environment misconfiguration rather
-    than masking it as a test assertion failure further down.
-    """
-    dirsql = shutil.which("dirsql")
-    assert dirsql is not None, (
-        "`dirsql` console script not on PATH -- run `uv run maturin develop`"
-    )
-    return [dirsql]
-
-
-def spawn(config_path: Path) -> subprocess.Popen:
-    """Start `dirsql interpret <config>` with piped stdin/stdout/stderr."""
-    return subprocess.Popen(
-        [*cli_argv(), "interpret", str(config_path)],
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        bufsize=1,
-    )
-
-
-def readline(proc: subprocess.Popen, timeout: float = 5.0) -> str:
-    """Read one stdout line with a timeout.
-
-    On timeout, kill the process and surface stderr so the failure
-    message is actionable rather than an opaque hang.
-    """
-    result: list[str | None] = [None]
-
-    def reader() -> None:
-        assert proc.stdout is not None
-        result[0] = proc.stdout.readline()
-
-    t = threading.Thread(target=reader, daemon=True)
-    t.start()
-    t.join(timeout)
-    if t.is_alive():
-        proc.kill()
-        stderr = proc.stderr.read() if proc.stderr else ""
-        raise AssertionError(
-            f"timed out waiting for stdout line; stderr was:\n{stderr}"
-        )
-    line = result[0] or ""
-    if not line:
-        stderr = proc.stderr.read() if proc.stderr else ""
-        raise AssertionError(
-            f"helper exited (code={proc.returncode}) before writing a line; "
-            f"stderr was:\n{stderr}"
-        )
-    return line
-
-
-def send(proc: subprocess.Popen, msg: dict[str, Any]) -> None:
-    """Write one NDJSON line to the helper's stdin."""
-    assert proc.stdin is not None
-    proc.stdin.write(json.dumps(msg) + "\n")
-    proc.stdin.flush()
-
-
-def shutdown(proc: subprocess.Popen) -> None:
-    """Close stdin and wait for the helper to exit cleanly."""
-    if proc.stdin is not None:
-        try:
-            proc.stdin.close()
-        except BrokenPipeError:
-            pass
-    try:
-        proc.wait(timeout=5)
-    except subprocess.TimeoutExpired:
-        proc.kill()
-        proc.wait(timeout=2)