dirsql 0.4.46__tar.gz → 0.4.47__tar.gz

{dirsql-0.4.46 → dirsql-0.4.47}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.46"
+version = "0.4.47"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -597,7 +597,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.46"
+version = "0.4.47"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.46 → dirsql-0.4.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.46
+Version: 0.4.47
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.46 → dirsql-0.4.47}/dirsql/_dirsql.pyi

@@ -97,4 +97,6 @@ def plan_config_extensions(
     configs: list[tuple[str, str | None]],
 ) -> list[ExtensionPlanEntry] | None: ...
 def select_loadable(name: str, dirs: list[str], candidates: list[str]) -> str: ...
-def is_bare_name(path: str) -> bool: ...
+def plan_extension_path(
+    path: str, base: str, resolve_relative: bool
+) -> ExtensionPlanEntry: ...

{dirsql-0.4.46 → dirsql-0.4.47}/dirsql/resolve_extension.py

@@ -1,7 +1,8 @@
 """Resolve an extension entry's ``path`` to a concrete loadable file.
 
-Resolution is an ordered probe (file-first, then package), so only a bare
-package name reaches the package machinery:
+Resolution is an ordered probe (file-first, then package), planned by the core
+(``_dirsql.plan_extension_path``) and carried out here: only locating an
+installed package is host-specific.
 
 1. **Path-looking** (contains a separator, or ends in ``.so`` / ``.dylib`` /
    ``.dll`` / ``.pyd``) -- returned as a file path: made absolute against
@@ -13,10 +14,8 @@ package name reaches the package machinery:
    picked from inside it.
 """
 
-import os
-
-from ._dirsql import is_bare_name
-from .resolve_package import _resolve_package
+from ._dirsql import plan_extension_path
+from .plan_entry_path import _plan_entry_path
 
 
 def resolve_extension_path(path, base, resolve_relative):
@@ -28,11 +27,4 @@ def resolve_extension_path(path, base, resolve_relative):
     against ``base`` (config-file semantics); when false it is returned verbatim
     (programmatic semantics).
     """
-    if not is_bare_name(path):
-        if resolve_relative and not os.path.isabs(path):
-            return os.path.join(base, path)
-        return path
-    local = os.path.join(base, path)
-    if os.path.isfile(local):
-        return local
-    return _resolve_package(path)
+    return _plan_entry_path(plan_extension_path(path, base, resolve_relative))

{dirsql-0.4.46 → dirsql-0.4.47}/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.4.46"
+version = "0.4.47"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

dirsql-0.4.47/packages/python/changelog.d/2026-09-18-programmatic-extension-plan.md

@@ -0,0 +1,8 @@
+**Changed**
+
+- `resolve_extension_path` now plans through the core
+  (`_dirsql.plan_extension_path`) instead of re-implementing the ordered probe,
+  so a programmatic `extensions=[{path}]` entry is classified by the same code
+  as a config entry. `importlib` package lookup is unchanged, and so is the
+  resolved path. The internal `_dirsql.is_bare_name` binding export is gone,
+  replaced by `plan_extension_path`. No change to the published API. (#1122)

dirsql-0.4.47/packages/python/e2e-attestations/claude-1122-ext-cleanup.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1789742374,
+  "exit_code": 0,
+  "commit": "c05317742ecadafeabc1f5de5ccffa75fa983756",
+  "branch": "claude/1122-ext-cleanup"
+}

{dirsql-0.4.46 → dirsql-0.4.47}/packages/python/src/lib.rs

@@ -573,10 +573,19 @@ mod python {
             .map_err(|err| err.to_string())
     }
 
-    /// Whether an extension entry names a package rather than a file.
+    /// Plan one extension path given outside a config file.
+    ///
+    /// `base` is the directory a relative path and the bare-name shadow probe
+    /// resolve against; `resolve_relative` makes a relative path-looking value
+    /// absolute against it (config semantics) rather than verbatim.
     #[pyfunction]
-    fn is_bare_name(path: &str) -> bool {
-        extension_resolution::is_bare_name(path, PY_SUFFIXES)
+    fn plan_extension_path(path: &str, base: &str, resolve_relative: bool) -> PyExtensionPlanEntry {
+        plan_entry_to_py(extension_resolution::plan_extension_path(
+            path,
+            Path::new(base),
+            resolve_relative,
+            PY_SUFFIXES,
+        ))
     }
 
     #[pymodule]
@@ -591,7 +600,7 @@ mod python {
         m.add_function(wrap_pyfunction!(config_paths_from_argv, m)?)?;
         m.add_function(wrap_pyfunction!(plan_config_extensions, m)?)?;
         m.add_function(wrap_pyfunction!(select_loadable, m)?)?;
-        m.add_function(wrap_pyfunction!(is_bare_name, m)?)?;
+        m.add_function(wrap_pyfunction!(plan_extension_path, m)?)?;
         m.add_class::<PyExtensionPlanEntry>()?;
         Ok(())
     }
@@ -763,11 +772,24 @@ mod python {
         }
 
         #[test]
-        fn is_bare_name_applies_the_cpython_suffix_list() {
-            assert!(is_bare_name("sqlite_vec"));
-            assert!(!is_bare_name("vec0.pyd"));
-            assert!(is_bare_name("vec0.node"));
-            assert!(!is_bare_name("ext/vec0"));
+        fn a_programmatic_path_marshals_as_a_literal_entry() {
+            let entry = plan_extension_path("ext/vec0.so", "/cwd", false);
+            assert_eq!(entry.path.as_deref(), Some("ext/vec0.so"));
+            assert_eq!(entry.package, None);
+            assert_eq!(
+                plan_extension_path("ext/vec0.so", "/cwd", true)
+                    .path
+                    .as_deref(),
+                Some("/cwd/ext/vec0.so")
+            );
+        }
+
+        #[test]
+        fn a_programmatic_entry_applies_the_cpython_suffix_list() {
+            let entry = plan_extension_path("vec0.node", "/cwd", false);
+            assert_eq!(entry.package.as_deref(), Some("vec0.node"));
+            assert_eq!(entry.shadow.as_deref(), Some("/cwd/vec0.node"));
+            assert_eq!(plan_extension_path("vec0.pyd", "/cwd", false).package, None);
         }
 
         #[test]

{dirsql-0.4.46 → dirsql-0.4.47}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.46"
+version = "0.4.47"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.46 → dirsql-0.4.47}/packages/rust/src/extension_resolution.rs

@@ -169,6 +169,38 @@ fn spec_is_bare_name(extension: &ExtensionSpec, suffixes: &[&str]) -> bool {
         .is_some_and(|path| is_bare_name(path, suffixes))
 }
 
+/// Plan one extension path given outside a config file.
+///
+/// A constructor's `extensions=[{path}]` entry takes the same ordered probe as
+/// a config entry: a path-looking value is literal, made absolute against
+/// `base` only when `resolve_relative` is set (config semantics; programmatic
+/// entries keep a relative path verbatim), and a bare name is a package whose
+/// shadow probe sits under `base`. The entry's `entrypoint` travels with the
+/// caller, so the returned entry carries none.
+pub fn plan_extension_path(
+    path: &str,
+    base: &Path,
+    resolve_relative: bool,
+    suffixes: &[&str],
+) -> PlanEntry {
+    if is_bare_name(path, suffixes) {
+        return PlanEntry::Package {
+            name: path.to_owned(),
+            shadow: base.join(path),
+            entrypoint: None,
+        };
+    }
+    PlanEntry::Literal {
+        // `join` yields an absolute path verbatim.
+        path: if resolve_relative {
+            base.join(path)
+        } else {
+            PathBuf::from(path)
+        },
+        entrypoint: None,
+    }
+}
+
 /// Pick the single loadable file for package `name` out of a host's listing.
 ///
 /// `dirs` are the package's directories (used only for the not-found message);
@@ -209,7 +241,8 @@ pub fn select_loadable(
 #[cfg(test)]
 mod tests {
     use super::{
-        ConfigSource, PlanEntry, SelectError, is_bare_name, plan_config_extensions, select_loadable,
+        ConfigSource, PlanEntry, SelectError, is_bare_name, plan_config_extensions,
+        plan_extension_path, select_loadable,
     };
     use std::path::{Path, PathBuf};
 
@@ -357,6 +390,70 @@ mod tests {
         );
     }
 
+    #[test]
+    fn a_programmatic_relative_path_is_made_absolute_only_when_asked() {
+        let base = Path::new("/cwd");
+        assert_eq!(
+            plan_extension_path("ext/vec0.so", base, true, PY),
+            PlanEntry::Literal {
+                path: PathBuf::from("/cwd/ext/vec0.so"),
+                entrypoint: None,
+            }
+        );
+        assert_eq!(
+            plan_extension_path("ext/vec0.so", base, false, PY),
+            PlanEntry::Literal {
+                path: PathBuf::from("ext/vec0.so"),
+                entrypoint: None,
+            }
+        );
+    }
+
+    #[test]
+    fn a_programmatic_absolute_path_is_left_alone() {
+        assert_eq!(
+            plan_extension_path("/opt/vec0.so", Path::new("/cwd"), true, PY),
+            PlanEntry::Literal {
+                path: PathBuf::from("/opt/vec0.so"),
+                entrypoint: None,
+            }
+        );
+    }
+
+    #[test]
+    fn a_programmatic_bare_name_plans_a_package_shadowed_by_base() {
+        for resolve_relative in [true, false] {
+            assert_eq!(
+                plan_extension_path("sqlite_vec", Path::new("/cwd"), resolve_relative, PY),
+                PlanEntry::Package {
+                    name: "sqlite_vec".into(),
+                    shadow: PathBuf::from("/cwd/sqlite_vec"),
+                    entrypoint: None,
+                }
+            );
+        }
+    }
+
+    #[test]
+    fn a_programmatic_entry_uses_the_hosts_own_suffix_list() {
+        let base = Path::new("/cwd");
+        assert_eq!(
+            plan_extension_path("vec0.node", base, true, PY),
+            PlanEntry::Package {
+                name: "vec0.node".into(),
+                shadow: PathBuf::from("/cwd/vec0.node"),
+                entrypoint: None,
+            }
+        );
+        assert_eq!(
+            plan_extension_path("vec0.node", base, true, NODE),
+            PlanEntry::Literal {
+                path: PathBuf::from("/cwd/vec0.node"),
+                entrypoint: None,
+            }
+        );
+    }
+
     #[test]
     fn select_loadable_returns_the_single_matching_file() {
         let dir = PathBuf::from("/site-packages/sqlite_vec");