dirsql 0.4.44__tar.gz → 0.4.46__tar.gz

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

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

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

@@ -1,7 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.44
-Requires-Dist: tomli>=2 ; python_full_version < '3.11'
+Version: 0.4.46
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

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

@@ -78,4 +78,23 @@ class DirSQL:
     def _start_watcher(self) -> None: ...
     def _poll_events(self, timeout_ms: int) -> list[RowEvent]: ...
 
+class ExtensionPlanEntry:
+    """One planned ``[[dirsql.extension]]`` entry. Exactly one of ``path`` and
+    ``package`` is set: a ``path`` is ready to load, a ``package`` must be
+    located with ``importlib`` -- unless ``shadow`` names an existing file,
+    which takes precedence over the package."""
+
+    path: str | None
+    package: str | None
+    shadow: str | None
+    entrypoint: str | None
+
+    @override
+    def __repr__(self) -> str: ...
+
 def config_paths_from_argv(argv: list[str]) -> list[str]: ...
+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: ...

dirsql-0.4.46/dirsql/plan_entry_path.py

@@ -0,0 +1,20 @@
+"""The loadable path one planned extension entry resolves to."""
+
+from __future__ import annotations
+
+import os
+
+from .resolve_package import _resolve_package
+
+
+def _plan_entry_path(entry):
+    """Resolve a planned entry to a concrete file.
+
+    A literal entry is already resolved. A package entry prefers a same-named
+    file shadowing it next to the config, then the installed package.
+    """
+    if entry.path is not None:
+        return entry.path
+    if os.path.isfile(entry.shadow):
+        return entry.shadow
+    return _resolve_package(entry.package)

dirsql-0.4.46/dirsql/read_config.py

@@ -0,0 +1,15 @@
+"""Reading one TOML config off disk for the core's extension planner."""
+
+from __future__ import annotations
+
+
+def _read_config(config_path):
+    """Return the config's text, or ``None`` when it cannot be read.
+
+    A missing or unreadable config is left for the core to report.
+    """
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            return f.read()
+    except OSError:
+        return None

{dirsql-0.4.44 → dirsql-0.4.46}/dirsql/resolve_configs_extension_specs.py

@@ -1,15 +1,19 @@
 """Resolution of several TOML configs' ``[[dirsql.extension]]`` entries, in order.
 
-The plural counterpart to :func:`dirsql.resolve_config_extensions
-.resolve_config_extension_specs`, used by the SDK constructor and the CLI
-launcher when argv carries more than one ``--config``.
+The planning -- which configs parse, whether any entry names a package rather
+than a file, and what each literal path resolves to against its own config's
+directory -- lives in the Rust core (``_dirsql.plan_config_extensions``). This
+module supplies the two host-specific halves the core cannot have: reading the
+files, and locating an installed package with ``importlib``.
 """
 
 from __future__ import annotations
 
-from .has_bare_name import _has_bare_name
-from .load_extension_entries import _load_extension_entries
-from .resolve_entries import _resolve_entries
+import os
+
+from ._dirsql import plan_config_extensions
+from .plan_entry_path import _plan_entry_path
+from .read_config import _read_config
 
 
 def resolve_configs_extension_specs(config_paths):
@@ -24,13 +28,11 @@ def resolve_configs_extension_specs(config_paths):
     the resolved list. Returns ``None`` when no config uses a package name,
     leaving every config's loading to the core.
     """
-    loaded = [_load_extension_entries(p) for p in config_paths]
-    if not any(item is not None and _has_bare_name(item[0]) for item in loaded):
+    sources = [(os.path.abspath(p), _read_config(p)) for p in config_paths]
+    plan = plan_config_extensions(sources)
+    if plan is None:
         return None
-    specs = []
-    for item in loaded:
-        if item is None:
-            continue
-        entries, base = item
-        specs.extend(_resolve_entries(entries, base))
-    return specs
+    return [
+        {"path": _plan_entry_path(entry), "entrypoint": entry.entrypoint}
+        for entry in plan
+    ]

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

@@ -10,12 +10,12 @@ package name reaches the package machinery:
 2. **Bare name** -- a same-named local file under ``base`` *shadows* the
    package; otherwise the package dir is located via
    :func:`importlib.util.find_spec` and the current platform's loadable is
-   globbed from inside it.
+   picked from inside it.
 """
 
 import os
 
-from .is_bare_name import is_bare_name
+from ._dirsql import is_bare_name
 from .resolve_package import _resolve_package
 
 

dirsql-0.4.46/dirsql/resolve_package.py

@@ -0,0 +1,37 @@
+"""Location of an extension package's loadable file for this platform.
+
+``importlib`` finds the package's directories; the core picks the one loadable
+file inside them (and raises on zero or several -- the caller must then
+disambiguate with a literal path).
+"""
+
+import glob as _glob
+import importlib.util
+import os
+
+from ._dirsql import select_loadable
+
+
+def _resolve_package(name):
+    """Locate ``name``'s package dir and pick its platform loadable file."""
+    try:
+        spec = importlib.util.find_spec(name)
+    except (ImportError, ValueError) as exc:
+        raise ValueError(
+            f"could not resolve extension package {name!r}: {exc}"
+        ) from exc
+    if spec is None:
+        raise ValueError(f"could not resolve extension package {name!r}: not installed")
+
+    dirs = list(spec.submodule_search_locations or [])
+    if not dirs and spec.origin and spec.origin not in ("built-in", "frozen"):
+        dirs.append(os.path.dirname(spec.origin))
+    if not dirs:
+        raise ValueError(
+            f"could not resolve extension package {name!r}: no package directory"
+        )
+
+    candidates = []
+    for d in dirs:
+        candidates.extend(_glob.glob(os.path.join(d, "**", "*"), recursive=True))
+    return select_loadable(name, dirs, candidates)

{dirsql-0.4.44 → dirsql-0.4.46}/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.44"
+version = "0.4.46"
 # 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.46/packages/python/changelog.d/2026-09-17-extension-resolution-via-core.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **Extension resolution now plans in the Rust core.** `resolve_configs_extension_specs` reads each config off disk and hands `(path, contents)` pairs to `dirsql._dirsql.plan_config_extensions`; `_resolve_package` hands the located package directories and their files to `dirsql._dirsql.select_loadable`; `resolve_extension_path` classifies through `dirsql._dirsql.is_bare_name`. Python keeps only the two host-specific halves — reading the files, and `importlib.util.find_spec`. Seven internal modules go away (`is_bare_name`, `has_bare_name`, `load_extension_entries`, `resolve_entries`, `platform_patterns`, `resolve_config_extensions`, `toml_module`) against two added (`read_config`, `plan_entry_path`), and with them the `tomli` dependency on Python 3.10. No change to the published API or CLI behavior. (#1120)

dirsql-0.4.46/packages/python/e2e-attestations/claude-1120-py-ext.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1789678578,
+  "exit_code": 0,
+  "commit": "98c2126ee5ab39e608a0ad9805b223f96f576a65",
+  "branch": "claude/1120-py-ext"
+}

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

@@ -12,12 +12,13 @@
 
 #[cfg(feature = "extension-module")]
 mod python {
+    use ::dirsql::extension_resolution::{self, ConfigSource, PlanEntry};
     use ::dirsql::{DirSQL, Extension, Row, RowEvent, Table, Value};
-    use pyo3::exceptions::{PyOverflowError, PyRuntimeError};
+    use pyo3::exceptions::{PyOverflowError, PyRuntimeError, PyValueError};
     use pyo3::prelude::*;
     use pyo3::types::{PyBool, PyByteArray, PyBytes, PyDict, PyInt, PyList};
     use std::collections::HashMap;
-    use std::path::PathBuf;
+    use std::path::{Path, PathBuf};
     use std::time::Duration;
 
     /// A table definition. Mirrors `dirsql::Table` but holds a Python
@@ -469,6 +470,115 @@ mod python {
         dirsql::launcher::config_paths_from_argv(&argv)
     }
 
+    /// The loadable-file suffixes a CPython host recognizes.
+    const PY_SUFFIXES: &[&str] = &[".so", ".dylib", ".dll", ".pyd"];
+
+    /// The subset this platform actually builds, used when picking a
+    /// package's loadable out of everything installed beside it.
+    #[cfg(target_os = "macos")]
+    const PLATFORM_SUFFIXES: &[&str] = &[".dylib"];
+    #[cfg(target_os = "windows")]
+    const PLATFORM_SUFFIXES: &[&str] = &[".dll", ".pyd"];
+    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+    const PLATFORM_SUFFIXES: &[&str] = &[".so"];
+
+    /// One planned `[[dirsql.extension]]` entry.
+    ///
+    /// Exactly one of `path` and `package` is set: a `path` is ready to load,
+    /// a `package` must be located with `importlib` first — unless `shadow`
+    /// names an existing file, which takes precedence over the package.
+    #[pyclass(name = "ExtensionPlanEntry", frozen)]
+    struct PyExtensionPlanEntry {
+        #[pyo3(get)]
+        path: Option<String>,
+        #[pyo3(get)]
+        package: Option<String>,
+        #[pyo3(get)]
+        shadow: Option<String>,
+        #[pyo3(get)]
+        entrypoint: Option<String>,
+    }
+
+    #[pymethods]
+    impl PyExtensionPlanEntry {
+        fn __repr__(&self) -> String {
+            format!(
+                "ExtensionPlanEntry(path={:?}, package={:?}, shadow={:?}, entrypoint={:?})",
+                self.path, self.package, self.shadow, self.entrypoint
+            )
+        }
+    }
+
+    fn plan_entry_to_py(entry: PlanEntry) -> PyExtensionPlanEntry {
+        match entry {
+            PlanEntry::Literal { path, entrypoint } => PyExtensionPlanEntry {
+                path: Some(display(&path)),
+                package: None,
+                shadow: None,
+                entrypoint,
+            },
+            PlanEntry::Package {
+                name,
+                shadow,
+                entrypoint,
+            } => PyExtensionPlanEntry {
+                path: None,
+                package: Some(name),
+                shadow: Some(display(&shadow)),
+                entrypoint,
+            },
+        }
+    }
+
+    fn display(path: &Path) -> String {
+        path.to_string_lossy().into_owned()
+    }
+
+    /// Plan several configs' `[[dirsql.extension]]` entries.
+    ///
+    /// `configs` pairs each config's absolute path with its contents, or
+    /// `None` when the launcher could not read it. `None` back means no entry
+    /// names a package, so the core's own config loading handles them all.
+    #[pyfunction]
+    fn plan_config_extensions(
+        configs: Vec<(String, Option<String>)>,
+    ) -> Option<Vec<PyExtensionPlanEntry>> {
+        let sources: Vec<ConfigSource<'_>> = configs
+            .iter()
+            .map(|(path, contents)| ConfigSource {
+                path: Path::new(path),
+                contents: contents.as_deref(),
+            })
+            .collect();
+        let plan = extension_resolution::plan_config_extensions(&sources, PY_SUFFIXES)?;
+        Some(plan.into_iter().map(plan_entry_to_py).collect())
+    }
+
+    /// Pick package `name`'s single loadable file out of `candidates`.
+    #[pyfunction]
+    fn select_loadable(name: &str, dirs: Vec<String>, candidates: Vec<String>) -> PyResult<String> {
+        selected_loadable(name, dirs, candidates).map_err(PyValueError::new_err)
+    }
+
+    /// The interpreter-free half of [`select_loadable`], so it stays unit-testable.
+    fn selected_loadable(
+        name: &str,
+        dirs: Vec<String>,
+        candidates: Vec<String>,
+    ) -> Result<String, String> {
+        let dirs: Vec<PathBuf> = dirs.into_iter().map(PathBuf::from).collect();
+        let candidates: Vec<PathBuf> = candidates.into_iter().map(PathBuf::from).collect();
+        extension_resolution::select_loadable(name, &dirs, &candidates, PLATFORM_SUFFIXES)
+            .map(|path| display(&path))
+            .map_err(|err| err.to_string())
+    }
+
+    /// Whether an extension entry names a package rather than a file.
+    #[pyfunction]
+    fn is_bare_name(path: &str) -> bool {
+        extension_resolution::is_bare_name(path, PY_SUFFIXES)
+    }
+
     #[pymodule]
     #[pyo3(name = "_dirsql")]
     fn py_dirsql_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -479,6 +589,10 @@ mod python {
         m.add_class::<PyScanFailure>()?;
         m.add_function(wrap_pyfunction!(run_cli, m)?)?;
         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_class::<PyExtensionPlanEntry>()?;
         Ok(())
     }
 
@@ -561,6 +675,101 @@ mod python {
             assert_eq!(OnFileError("bad".to_string()).to_string(), "bad");
         }
 
+        #[test]
+        fn planning_returns_none_when_no_entry_names_a_package() {
+            let plan = plan_config_extensions(vec![(
+                "/cfg/.dirsql.toml".into(),
+                Some("[[dirsql.extension]]\npath = \"vec0.so\"\n".into()),
+            )]);
+            assert!(plan.is_none());
+        }
+
+        #[test]
+        fn planning_marshals_a_literal_against_its_own_config_directory() {
+            let plan = plan_config_extensions(vec![(
+                "/cfg/.dirsql.toml".into(),
+                Some(
+                    "[[dirsql.extension]]\npath = \"ext/vec0.so\"\nentrypoint = \"init\"\n\n[[dirsql.extension]]\npath = \"sqlite_vec\"\n"
+                        .into(),
+                ),
+            )])
+            .expect("a bare name makes the SDK intervene");
+
+            assert_eq!(plan[0].path.as_deref(), Some("/cfg/ext/vec0.so"));
+            assert_eq!(plan[0].package, None);
+            assert_eq!(plan[0].shadow, None);
+            assert_eq!(plan[0].entrypoint.as_deref(), Some("init"));
+        }
+
+        #[test]
+        fn planning_marshals_a_package_with_its_shadow_probe() {
+            let plan = plan_config_extensions(vec![(
+                "/cfg/.dirsql.toml".into(),
+                Some("[[dirsql.extension]]\npath = \"sqlite_vec\"\n".into()),
+            )])
+            .expect("a bare name makes the SDK intervene");
+
+            assert_eq!(plan[0].path, None);
+            assert_eq!(plan[0].package.as_deref(), Some("sqlite_vec"));
+            assert_eq!(plan[0].shadow.as_deref(), Some("/cfg/sqlite_vec"));
+            assert_eq!(plan[0].entrypoint, None);
+        }
+
+        #[test]
+        fn an_unreadable_config_is_skipped_rather_than_reported() {
+            assert!(plan_config_extensions(vec![("/cfg/.dirsql.toml".into(), None)]).is_none());
+        }
+
+        #[test]
+        fn plan_entry_repr_names_every_field() {
+            let entry = plan_entry_to_py(PlanEntry::Package {
+                name: "vec".into(),
+                shadow: "/cfg/vec".into(),
+                entrypoint: Some("init".into()),
+            });
+            assert_eq!(
+                entry.__repr__(),
+                "ExtensionPlanEntry(path=None, package=Some(\"vec\"), shadow=Some(\"/cfg/vec\"), entrypoint=Some(\"init\"))"
+            );
+        }
+
+        #[cfg(target_os = "macos")]
+        const EXPECTED_PATTERNS: &str = "*.dylib";
+        #[cfg(target_os = "windows")]
+        const EXPECTED_PATTERNS: &str = "*.dll / *.pyd";
+        #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+        const EXPECTED_PATTERNS: &str = "*.so";
+
+        #[test]
+        fn select_loadable_returns_the_single_match() {
+            let found = selected_loadable(
+                "vec",
+                vec!["/pkg".into()],
+                vec!["/pkg/__init__.py".into(), "/pkg/vec0.so".into()],
+            );
+            assert_eq!(found, Ok("/pkg/vec0.so".to_string()));
+        }
+
+        #[test]
+        fn select_loadable_carries_the_cores_message_verbatim() {
+            let err = selected_loadable("vec", vec!["/pkg".into()], vec![])
+                .expect_err("no loadable file");
+            assert_eq!(
+                err,
+                format!(
+                    "no loadable extension file ({EXPECTED_PATTERNS}) found in package 'vec' (searched /pkg)"
+                )
+            );
+        }
+
+        #[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"));
+        }
+
         #[test]
         fn config_paths_from_argv_forwards_to_the_core_scan() {
             assert_eq!(

{dirsql-0.4.44 → dirsql-0.4.46}/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.44"
+version = "0.4.46"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.44 → dirsql-0.4.46}/pyproject.toml

@@ -19,10 +19,6 @@ repository = "https://github.com/thekevinscott/dirsql"
 keywords = ["sql", "filesystem", "directory", "sqlite", "index"]
 readme = "README.md"
 dependencies = [
-    # `tomllib` is stdlib only on 3.11+; `resolve_config_extensions` falls back
-    # to the backport it was derived from. Drop this the day the floor reaches
-    # 3.11 again.
-    'tomli>=2; python_version < "3.11"',
     # The console script runs the CLI in-process through this (#738); without
     # it `dirsql.cli.main` cannot import.
     "bin-shim>=0.1",

dirsql-0.4.44/dirsql/has_bare_name.py

@@ -1,14 +0,0 @@
-"""Whether any of a config's extension entries names a package."""
-
-from __future__ import annotations
-
-from .is_bare_name import is_bare_name
-
-
-def _has_bare_name(entries):
-    return any(
-        isinstance(e, dict)
-        and isinstance(e.get("path"), str)
-        and is_bare_name(e["path"])
-        for e in entries
-    )

dirsql-0.4.44/dirsql/is_bare_name.py

@@ -1,14 +0,0 @@
-"""Whether an extension ``path`` names a package rather than a file."""
-
-import os
-
-# Suffixes that mark a value as "already a file path", so package resolution
-# is never attempted.
-_LOADABLE_SUFFIXES = (".so", ".dylib", ".dll", ".pyd")
-
-
-def is_bare_name(path):
-    """True when ``path`` is a bare package name rather than a file path."""
-    if os.sep in path or (os.altsep and os.altsep in path):
-        return False
-    return not path.endswith(_LOADABLE_SUFFIXES)

dirsql-0.4.44/dirsql/load_extension_entries.py

@@ -1,28 +0,0 @@
-"""Reading one TOML config's ``[[dirsql.extension]]`` array off disk."""
-
-from __future__ import annotations
-
-import os
-
-from .toml_module import _toml
-
-
-def _load_extension_entries(config_path):
-    """Return ``(entries, base_dir)`` for a config's ``[[dirsql.extension]]``.
-
-    ``None`` when the config is missing, unreadable/malformed, or declares no
-    extension array -- the caller should leave such configs to the core.
-    """
-    if not os.path.isfile(config_path):
-        return None
-    try:
-        with open(config_path, "rb") as f:
-            doc = _toml.load(f)
-    except (OSError, _toml.TOMLDecodeError):
-        # Leave a malformed / unreadable config for the core to report.
-        return None
-
-    entries = (doc.get("dirsql") or {}).get("extension")
-    if not isinstance(entries, list):
-        return None
-    return entries, os.path.dirname(os.path.abspath(config_path))

dirsql-0.4.44/dirsql/platform_patterns.py

@@ -1,12 +0,0 @@
-"""The loadable-file glob pattern(s) the running platform uses."""
-
-import sys
-
-
-def _platform_patterns():
-    """Loadable-file glob(s) for the current platform."""
-    if sys.platform == "darwin":
-        return ("*.dylib",)
-    if sys.platform == "win32":
-        return ("*.dll", "*.pyd")
-    return ("*.so",)

dirsql-0.4.44/dirsql/resolve_config_extensions.py

@@ -1,39 +0,0 @@
-"""SDK-side resolution of a TOML config's ``[[dirsql.extension]]`` entries.
-
-The Rust core loads a config's extensions literally -- it has no
-``importlib``, so it cannot resolve a bare **package name**. 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 (``suppress_config_extensions``) so
-the config's entries are not loaded a second time.
-
-Shared by the ``DirSQL`` constructor (``config=`` path) and the CLI launcher
-(which converts the resolved specs into ``--extension`` flags), both of which
-reach it through :mod:`dirsql.resolve_configs_extension_specs`.
-"""
-
-from __future__ import annotations
-
-from .has_bare_name import _has_bare_name
-from .load_extension_entries import _load_extension_entries
-from .resolve_entries import _resolve_entries
-
-
-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.
-    """
-    loaded = _load_extension_entries(config_path)
-    if loaded is None:
-        return None
-    entries, base = loaded
-    if not _has_bare_name(entries):
-        return None
-    return _resolve_entries(entries, base)

dirsql-0.4.44/dirsql/resolve_entries.py

@@ -1,20 +0,0 @@
-"""Resolution of one config's ``[[dirsql.extension]]`` entries to literal paths."""
-
-from __future__ import annotations
-
-from .resolve_extension import resolve_extension_path
-
-
-def _resolve_entries(entries, base):
-    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