dirsql 0.3.50__tar.gz → 0.3.52__tar.gz

{dirsql-0.3.50 → dirsql-0.3.52}/Cargo.lock

@@ -501,7 +501,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.50"
+version = "0.3.52"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.50 → dirsql-0.3.52}/PKG-INFO

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

{dirsql-0.3.50 → dirsql-0.3.52}/dirsql/_async.py

@@ -4,6 +4,7 @@ import asyncio
 import os
 
 from dirsql._dirsql import DirSQL as _RustDirSQL
+from dirsql.resolve_config_extensions import resolve_config_extension_specs
 from dirsql.resolve_extension import resolve_extension_path
 
 
@@ -56,7 +57,9 @@ class DirSQL:
     Pass ``extensions`` -- a list of ``{"path": ..., "entrypoint": ...}`` dicts
     (``entrypoint`` optional) -- to load SQLite extensions onto the connection
     at startup. Any ``[[dirsql.extension]]`` entries in a ``config`` file are
-    appended after the programmatic ones.
+    appended after the programmatic ones. A ``path`` (programmatic or
+    config-file) may be a bare **package name**, resolved from the installed
+    package in the runtime env (#298 / #313).
     """
 
     def __init__(
@@ -85,28 +88,51 @@ class DirSQL:
     async def _init_bg(self):
         """Run the scan in the background."""
         try:
-            self._db = await asyncio.to_thread(
-                _RustDirSQL,
-                self._root,
-                tables=self._tables,
-                ignore=self._ignore,
-                config=self._config,
-                persist=self._persist,
-                persist_path=self._persist_path,
-                extensions=self._resolved_extensions(),
-            )
+            self._db = await asyncio.to_thread(self._build_db)
         except Exception as exc:
             self._init_error = exc
         finally:
             self._ready_event.set()
 
+    def _build_db(self):
+        """Resolve extensions and construct the Rust-backed instance.
+
+        Runs on a worker thread (via ``asyncio.to_thread``): both the
+        package-name resolution (``importlib`` + filesystem globs) and the
+        core's initial scan are blocking work.
+
+        When the ``config`` file names an extension by bare package name, the
+        SDK resolves every one of the config's ``[[dirsql.extension]]`` entries
+        itself (#313) -- appended after the programmatic ones, matching the
+        core's ordering -- and suppresses the core's own config-extension
+        loading so the entries are not loaded a second time (and the core never
+        sees the unresolvable bare name).
+        """
+        extensions = self._resolved_extensions()
+        suppress = False
+        if self._config is not None:
+            config_extensions = resolve_config_extension_specs(self._config)
+            if config_extensions is not None:
+                extensions = [*(extensions or []), *config_extensions]
+                suppress = True
+        return _RustDirSQL(
+            self._root,
+            tables=self._tables,
+            ignore=self._ignore,
+            config=self._config,
+            persist=self._persist,
+            persist_path=self._persist_path,
+            extensions=extensions,
+            suppress_config_extensions=suppress,
+        )
+
     def _resolved_extensions(self):
         """Resolve each programmatic extension's ``path`` to a loadable file.
 
         A bare package name is resolved to the loadable installed in the runtime
         env (#298); path-looking values are passed through verbatim (mirroring
         the Rust builder, which takes programmatic paths as-is). Config-file
-        ``[[dirsql.extension]]`` entries are resolved by the Rust core, not here.
+        ``[[dirsql.extension]]`` entries are handled by ``_build_db``.
         """
         if not self._extensions:
             return self._extensions

{dirsql-0.3.50 → dirsql-0.3.52}/dirsql/_dirsql.pyi

@@ -69,6 +69,7 @@ class DirSQL:
         persist: bool = False,
         persist_path: str | PathLike[str] | None = None,
         extensions: list[ExtensionSpec] | None = None,
+        suppress_config_extensions: bool = False,
     ) -> None: ...
     def query(self, sql: str) -> list[Row]: ...
     def _start_watcher(self) -> None: ...

{dirsql-0.3.50 → dirsql-0.3.52}/dirsql/cli/resolve_config_extensions.py

@@ -3,11 +3,12 @@
 Mirrors the TypeScript launcher. The compiled ``dirsql`` binary reads a
 ``.dirsql.toml`` itself and loads its extensions literally -- it has no
 ``importlib``, so it cannot resolve a bare **package name** (#227). This
-launcher can. When a TOML config names an extension by package name, we resolve
-every one of its extensions here and pass the resolved literal paths to the
-binary via repeatable ``--extension`` flags; the binary then loads those and
-ignores the config's own extension entries (the Rust ``--extension`` flag /
-``suppress_config_extensions``).
+launcher can. When a TOML config names an extension by package name, the
+shared SDK resolver (:mod:`dirsql.resolve_config_extensions`, #313) resolves
+every one of its extensions and this launcher passes the resolved literal
+paths to the binary via repeatable ``--extension`` flags; the binary then
+loads those and ignores the config's own extension entries (the Rust
+``--extension`` flag / ``suppress_config_extensions``).
 
 Native-language configs (``.py`` / ``.js`` / ``.mjs`` / ``.cjs``) are untouched:
 the binary dispatches those to ``dirsql interpret``, whose handshake already
@@ -16,10 +17,7 @@ carries resolved paths.
 
 from __future__ import annotations
 
-import os
-import tomllib
-
-from ..resolve_extension import is_bare_name, resolve_extension_path
+from ..resolve_config_extensions import resolve_config_extension_specs
 
 # Config extensions the binary dispatches to `dirsql interpret`; never
 # pre-resolved here (that path resolves via the handshake).
@@ -28,14 +26,12 @@ _NATIVE_SUFFIXES = (".py", ".js", ".mjs", ".cjs")
 
 def _config_path_from_argv(argv: list[str]) -> str:
     """The ``--config`` value (``--config X`` or ``--config=X``), or the default."""
-    i = 0
-    while i < len(argv):
-        a = argv[i]
+    for i, a in enumerate(argv):
         if a == "--config":
-            return argv[i + 1] if i + 1 < len(argv) else ""
+            # A bare trailing `--config` (no following value) yields "".
+            return next(iter(argv[i + 1 :]), "")
         if a.startswith("--config="):
             return a[len("--config=") :]
-        i += 1
     return "./.dirsql.toml"
 
 
@@ -48,34 +44,14 @@ def with_resolved_extensions(argv: list[str]) -> list[str]:
     config_path = _config_path_from_argv(argv)
     if config_path.endswith(_NATIVE_SUFFIXES):
         return argv
-    if not os.path.isfile(config_path):
-        return argv
-    try:
-        with open(config_path, "rb") as f:
-            doc = tomllib.load(f)
-    except (OSError, tomllib.TOMLDecodeError):
-        # Leave a malformed / unreadable config for the binary to report.
-        return argv
-
-    cfg = doc.get("dirsql") or {}
-    entries = cfg.get("extension") or []
-    if not isinstance(entries, list) or not entries:
-        return argv
-    # Only intervene when at least one path is a bare package name; a config
-    # with only literal paths keeps the binary's existing behavior untouched.
-    if not any(
-        isinstance(e, dict)
-        and isinstance(e.get("path"), str)
-        and is_bare_name(e["path"])
-        for e in entries
-    ):
+    specs = resolve_config_extension_specs(config_path)
+    if specs is None:
         return argv
-
-    base = os.path.dirname(os.path.abspath(config_path))
     flags: list[str] = []
-    for e in entries:
-        path = resolve_extension_path(e["path"], base=base, resolve_relative=True)
-        entrypoint = e.get("entrypoint")
+    for spec in specs:
+        entrypoint = spec["entrypoint"]
         flags.append("--extension")
-        flags.append(f"{path}::{entrypoint}" if isinstance(entrypoint, str) else path)
+        flags.append(
+            f"{spec['path']}::{entrypoint}" if entrypoint is not None else spec["path"]
+        )
     return [*argv, *flags]

dirsql-0.3.52/dirsql/resolve_config_extensions.py

@@ -0,0 +1,71 @@
+"""SDK-side resolution of a TOML config's ``[[dirsql.extension]]`` entries.
+
+The Rust core parses a ``.dirsql.toml`` itself and loads its extensions
+literally -- it has no ``importlib``, so it cannot resolve a bare **package
+name** (#227). The SDK can (#313). When a TOML config names an extension by
+package name, the SDK resolves every one of its extensions here, hands the
+core the resolved literal paths, and suppresses the core's own config-extension
+loading (the Rust ``suppress_config_extensions`` builder toggle) so the
+config's entries are not loaded a second time.
+
+Shared by the ``DirSQL`` constructor (``config=`` path) and the CLI launcher
+(``dirsql.cli.resolve_config_extensions``, which converts the resolved specs
+into ``--extension`` flags for the binary).
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+
+from .resolve_extension import is_bare_name, resolve_extension_path
+
+
+def resolve_config_extension_specs(config_path):
+    """Resolve a TOML config's ``[[dirsql.extension]]`` entries to literal paths.
+
+    Returns a list of ``{"path", "entrypoint"}`` dicts -- every entry resolved
+    via :func:`resolve_extension_path` against the config file's parent
+    directory -- when at least one entry's ``path`` is a bare package name.
+    Returns ``None`` when the caller should not intervene: the config is
+    missing, malformed, declares no extensions, or uses only literal paths --
+    leaving the core's own loading (and error reporting) untouched. Raises if
+    a package name cannot be resolved.
+    """
+    if not os.path.isfile(config_path):
+        return None
+    try:
+        with open(config_path, "rb") as f:
+            doc = tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        # Leave a malformed / unreadable config for the core to report.
+        return None
+
+    cfg = doc.get("dirsql") or {}
+    entries = cfg.get("extension")
+    if not isinstance(entries, list):
+        return None
+    # Only intervene when at least one path is a bare package name; a config
+    # with only literal paths (or no entries at all) keeps the core's existing
+    # behavior untouched.
+    if not any(
+        isinstance(e, dict)
+        and isinstance(e.get("path"), str)
+        and is_bare_name(e["path"])
+        for e in entries
+    ):
+        return None
+
+    base = os.path.dirname(os.path.abspath(config_path))
+    specs = []
+    for e in entries:
+        entrypoint = e.get("entrypoint")
+        specs.append(
+            {
+                "path": resolve_extension_path(
+                    e["path"], base=base, resolve_relative=True
+                ),
+                "entrypoint": entrypoint if isinstance(entrypoint, str) else None,
+            }
+        )
+    return specs

{dirsql-0.3.50 → dirsql-0.3.52}/dirsql/resolve_extension.py

@@ -73,18 +73,22 @@ def _resolve_package(name):
             matches.update(_glob.glob(os.path.join(d, "**", pat), recursive=True))
     found = sorted(matches)
 
-    pat_desc = " / ".join(patterns)
-    if not found:
-        raise ValueError(
-            f"no loadable extension file ({pat_desc}) found in package "
-            f"{name!r} (searched {', '.join(dirs)})"
-        )
-    if len(found) > 1:
+    # Exactly one loadable resolves; unpacking (rather than a guarded
+    # subscript) makes the zero- and multiple-match failures each observable.
+    try:
+        (single,) = found
+    except ValueError:
+        pat_desc = " / ".join(patterns)
+        if not found:
+            raise ValueError(
+                f"no loadable extension file ({pat_desc}) found in package "
+                f"{name!r} (searched {', '.join(dirs)})"
+            ) from None
         raise ValueError(
             f"multiple loadable extension files found in package {name!r}: "
             f"{', '.join(found)}; disambiguate with a literal path"
-        )
-    return found[0]
+        ) from None
+    return single
 
 
 def resolve_extension_path(path, base, resolve_relative):

{dirsql-0.3.50 → dirsql-0.3.52}/docs/api/index.md

@@ -77,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 }`; TypeScript: `{ path, entrypoint? }` objects). A `path` is either a file path or a bare **package name**; a package name is resolved from the installed package (Python `importlib` / TypeScript `node_modules`, file-first, erroring on zero or multiple matches). This works on the Python/TypeScript constructor and CLI; the Rust binary and SDK are file-path-only. Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. 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). A `path` is either a file path or a bare **package name**; a package name is resolved from the installed package (Python `importlib` / TypeScript `node_modules`, file-first, erroring on zero or multiple matches). This works on the Python/TypeScript constructor — for both the programmatic `extensions` list and a `config` file's `[[dirsql.extension]]` entries — and on the CLI; the Rust binary and SDK are file-path-only. Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. See [Loading extensions](../cli/config.md#loading-extensions).
 
 ### Methods
 

{dirsql-0.3.50 → dirsql-0.3.52}/docs/cli/config.md

@@ -161,7 +161,9 @@ entrypoint = "sqlite3_myext_init"
 - **`path`** — the extension's shared library: either a file path (`.so` /
   `.dylib` / `.dll`, relative to the config file's directory) or a bare
   **package name**. A package name is resolved from the installed package when
-  run through the pip/npm `dirsql` CLI; the standalone Rust binary is
+  run through the pip/npm `dirsql` CLI, or when a Python/TypeScript `DirSQL`
+  loads the config in-process (`DirSQL(config=...)` /
+  `new DirSQL(configPath)`); the standalone Rust binary and the Rust SDK are
   file-path-only.
 - **`entrypoint`** *(optional)* — the extension's init symbol. When omitted,
   SQLite derives a default from the filename; set it when that default does not

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

{dirsql-0.3.50/packages/rust → dirsql-0.3.52/packages/python}/docs/api/index.md

@@ -77,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 }`; TypeScript: `{ path, entrypoint? }` objects). A `path` is either a file path or a bare **package name**; a package name is resolved from the installed package (Python `importlib` / TypeScript `node_modules`, file-first, erroring on zero or multiple matches). This works on the Python/TypeScript constructor and CLI; the Rust binary and SDK are file-path-only. Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. 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). A `path` is either a file path or a bare **package name**; a package name is resolved from the installed package (Python `importlib` / TypeScript `node_modules`, file-first, erroring on zero or multiple matches). This works on the Python/TypeScript constructor — for both the programmatic `extensions` list and a `config` file's `[[dirsql.extension]]` entries — and on the CLI; the Rust binary and SDK are file-path-only. Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. See [Loading extensions](../cli/config.md#loading-extensions).
 
 ### Methods
 

{dirsql-0.3.50/packages/rust → dirsql-0.3.52/packages/python}/docs/cli/config.md

@@ -161,7 +161,9 @@ entrypoint = "sqlite3_myext_init"
 - **`path`** — the extension's shared library: either a file path (`.so` /
   `.dylib` / `.dll`, relative to the config file's directory) or a bare
   **package name**. A package name is resolved from the installed package when
-  run through the pip/npm `dirsql` CLI; the standalone Rust binary is
+  run through the pip/npm `dirsql` CLI, or when a Python/TypeScript `DirSQL`
+  loads the config in-process (`DirSQL(config=...)` /
+  `new DirSQL(configPath)`); the standalone Rust binary and the Rust SDK are
   file-path-only.
 - **`entrypoint`** *(optional)* — the extension's init symbol. When omitted,
   SQLite derives a default from the filename; set it when that default does not

{dirsql-0.3.50 → dirsql-0.3.52}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783031403,
+  "ran_at": 1783076458,
   "exit_code": 0,
-  "commit": "3d7c9268191f94a3180442716aa1c49f48699776"
+  "commit": "b1df6dc7f05c1dec2c7189cd1489283b6b547478"
 }

{dirsql-0.3.50 → dirsql-0.3.52}/packages/python/src/lib.rs

@@ -114,8 +114,13 @@ mod python {
 
     #[pymethods]
     impl PyDirSQL {
+        /// `suppress_config_extensions` skips the core's own loading of the
+        /// config's `[[dirsql.extension]]` entries; the SDK sets it after
+        /// resolving those entries itself (package names need `importlib`,
+        /// which the core lacks -- #313) and passing the resolved literal
+        /// paths via `extensions`, so the entries are not loaded twice.
         #[new]
-        #[pyo3(signature = (root=None, *, tables=None, ignore=None, config=None, persist=false, persist_path=None, extensions=None))]
+        #[pyo3(signature = (root=None, *, tables=None, ignore=None, config=None, persist=false, persist_path=None, extensions=None, suppress_config_extensions=false))]
         fn new(
             py: Python<'_>,
             root: Option<String>,
@@ -125,6 +130,7 @@ mod python {
             persist: bool,
             persist_path: Option<PathBuf>,
             extensions: Option<Vec<PyExtensionSpec>>,
+            suppress_config_extensions: bool,
         ) -> PyResult<Self> {
             let rust_tables: Vec<Table> = tables
                 .as_deref()
@@ -164,7 +170,9 @@ mod python {
                     if !rust_extensions.is_empty() {
                         builder = builder.extensions(rust_extensions);
                     }
-                    builder.build()
+                    builder
+                        .suppress_config_extensions(suppress_config_extensions)
+                        .build()
                 })
                 .map_err(to_py_err)?;
 

{dirsql-0.3.50/packages/python → dirsql-0.3.52/packages/rust}/docs/api/index.md

@@ -77,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 }`; TypeScript: `{ path, entrypoint? }` objects). A `path` is either a file path or a bare **package name**; a package name is resolved from the installed package (Python `importlib` / TypeScript `node_modules`, file-first, erroring on zero or multiple matches). This works on the Python/TypeScript constructor and CLI; the Rust binary and SDK are file-path-only. Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. 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). A `path` is either a file path or a bare **package name**; a package name is resolved from the installed package (Python `importlib` / TypeScript `node_modules`, file-first, erroring on zero or multiple matches). This works on the Python/TypeScript constructor — for both the programmatic `extensions` list and a `config` file's `[[dirsql.extension]]` entries — and on the CLI; the Rust binary and SDK are file-path-only. Programmatic entries load first, then any `[[dirsql.extension]]` from `config`. See [Loading extensions](../cli/config.md#loading-extensions).
 
 ### Methods
 

{dirsql-0.3.50/packages/python → dirsql-0.3.52/packages/rust}/docs/cli/config.md

@@ -161,7 +161,9 @@ entrypoint = "sqlite3_myext_init"
 - **`path`** — the extension's shared library: either a file path (`.so` /
   `.dylib` / `.dll`, relative to the config file's directory) or a bare
   **package name**. A package name is resolved from the installed package when
-  run through the pip/npm `dirsql` CLI; the standalone Rust binary is
+  run through the pip/npm `dirsql` CLI, or when a Python/TypeScript `DirSQL`
+  loads the config in-process (`DirSQL(config=...)` /
+  `new DirSQL(configPath)`); the standalone Rust binary and the Rust SDK are
   file-path-only.
 - **`entrypoint`** *(optional)* — the extension's init symbol. When omitted,
   SQLite derives a default from the filename; set it when that default does not