dirsql 0.4.0__tar.gz → 0.4.2__tar.gz

{dirsql-0.4.0 → dirsql-0.4.2}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.0 → dirsql-0.4.2}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.0
+Version: 0.4.2
+Requires-Dist: tomli>=2 ; python_full_version < '3.11'
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott
 License-Expression: MIT
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 # `dirsql` (Python SDK)

{dirsql-0.4.0 → dirsql-0.4.2}/dirsql/_dirsql.pyi

@@ -11,9 +11,9 @@ same PR -- and ``PARITY.md`` is the canonical reminder.
 
 from collections.abc import Callable
 from os import PathLike
-from typing import Any, NotRequired, TypedDict
+from typing import Any, TypedDict
 
-from typing_extensions import override
+from typing_extensions import NotRequired, override
 
 __version__: str
 

{dirsql-0.4.0 → dirsql-0.4.2}/dirsql/cli/binary_path.py

@@ -9,7 +9,10 @@ from dirsql.cli.is_windows import is_windows
 
 def binary_path() -> str:
     name = "dirsql.exe" if is_windows() else "dirsql"
-    path = files("dirsql").joinpath("_binary", name)
+    # Chained rather than `joinpath("_binary", name)`: multi-segment joinpath
+    # is 3.11+, and `files()` returns a bare `Traversable` for non-filesystem
+    # loaders.
+    path = files("dirsql").joinpath("_binary").joinpath(name)
     if not path.is_file():
         raise FileNotFoundError(
             f"bundled `{name}` not found at {path}. The dirsql PyPI wheel "

{dirsql-0.4.0 → dirsql-0.4.2}/dirsql/resolve_config_extensions.py

@@ -14,11 +14,29 @@ Shared by the ``DirSQL`` constructor (``config=`` path) and the CLI launcher
 from __future__ import annotations
 
 import os
-import tomllib
+import sys
+from importlib import import_module
 
 from .resolve_extension import is_bare_name, resolve_extension_path
 
 
+def _load_toml_module():
+    """Return the TOML parser module for the running interpreter.
+
+    ``tomllib`` is stdlib only on 3.11+; on 3.10 the ``tomli`` backport it was
+    derived from (a version-gated dependency) provides the same surface.
+    Imported by name so a unit test can exercise both arms on any
+    interpreter -- a literal ``import tomllib`` is unreachable on 3.10 no
+    matter what ``sys.version_info`` claims.
+    """
+    if sys.version_info >= (3, 11):
+        return import_module("tomllib")
+    return import_module("tomli")
+
+
+_toml = _load_toml_module()
+
+
 def _load_extension_entries(config_path):
     """Return ``(entries, base_dir)`` for a config's ``[[dirsql.extension]]``.
 
@@ -29,8 +47,8 @@ def _load_extension_entries(config_path):
         return None
     try:
         with open(config_path, "rb") as f:
-            doc = tomllib.load(f)
-    except (OSError, tomllib.TOMLDecodeError):
+            doc = _toml.load(f)
+    except (OSError, _toml.TOMLDecodeError):
         # Leave a malformed / unreadable config for the core to report.
         return None
 

{dirsql-0.4.0 → dirsql-0.4.2}/packages/python/Cargo.toml

@@ -4,10 +4,10 @@ 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.0"
-# abi3 note: the `abi3-py311` pyo3 feature (below) builds ONE stable-ABI
-# `cp311-abi3` wheel per platform that loads on every CPython >= 3.11
-# (matching `pyproject.toml`'s `requires-python = ">=3.11"`), instead of
+version = "0.4.2"
+# 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
 # one wheel per interpreter. putitoutthere's `wheel-abi` detector (#401)
 # reads the abi3 feature straight off this direct `pyo3` dependency and
 # collapses the per-version build fan to a single wheel -- no
@@ -23,7 +23,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 dirsql.workspace = true
-pyo3 = { version = "0.28", features = ["extension-module", "generate-import-lib", "abi3-py311"], optional = true }
+pyo3 = { version = "0.28", features = ["extension-module", "generate-import-lib", "abi3-py310"], optional = true }
 
 [features]
 default = []

dirsql-0.4.2/packages/python/changelog.d/2026-07-29-restore-python-310.md

@@ -0,0 +1,3 @@
+**Added**
+
+- **Python 3.10 is supported again.** `requires-python` drops back to `>=3.10`, reversing the 0.3.6 raise to `>=3.11` — that raise was release tooling, not the API, and putitoutthere#401 cleared it by collapsing dirsql's abi3 wheel to a single row built on the newest interpreter. The pyo3 feature moves `abi3-py311` → `abi3-py310` in lock-step, so the wheel tag becomes `cp310-abi3` and still loads on every CPython from 3.10 up. `resolve_config_extensions` picks up the `tomli` backport (a new `python_version < "3.11"` dependency) since `tomllib` is stdlib only on 3.11+, and `binary_path` stops relying on 3.11's multi-segment `Traversable.joinpath`. The unit / integration / binding CI matrices gain a 3.10 leg so the declared floor is exercised rather than asserted. (#698)

dirsql-0.4.2/packages/python/e2e-attestations/claude-710-accumulate-onfile.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785444370,
+  "exit_code": 0,
+  "commit": "287fb980b2380a894543a652a0439f6ab8ea71cf",
+  "branch": "claude/710-accumulate-onfile"
+}

dirsql-0.4.2/packages/python/migrations.d/2026-07-29-restore-python-310.md

@@ -0,0 +1,50 @@
+### Python 3.10 support restored (#698)
+
+#### Summary
+
+`requires-python` is lowered from `>=3.11` back to `>=3.10`, reversing the drop
+made in 0.3.6 ("Python 3.10 support dropped"). No public API changes: this is a
+packaging/installability change plus the wheel-tag change that follows it.
+
+The 0.3.6 drop was forced by release tooling, not by the codebase — putitoutthere's
+multi-version wheel fan ran an `import tomllib` verify step on every row, so the
+3.10 row crashed the release build. Since putitoutthere#401 a wheel detected as
+Python-version-independent (dirsql's pyo3 `abi3-pyXY` feature, read off
+`packages/python/Cargo.toml`) collapses to a single wheel row built on the
+**newest** resolved interpreter, so that verify step never runs on 3.10 again.
+
+#### Required changes
+
+_None._ Every 3.11+ install keeps resolving and installing exactly as before.
+
+| Before | After | Action |
+| ------ | ----- | ------ |
+| `pip install dirsql` on 3.10 → `Requires-Python >=3.11`, no candidate | resolves and installs | None — upgrading Python is no longer required. |
+| Wheel filename `…-cp311-abi3-<platform>.whl` | `…-cp310-abi3-<platform>.whl` | Only if you **pin or hash exact wheel filenames** (lockfile with hashes, vendored artifact mirror, CI cache key): re-resolve so the new `cp310-abi3` name is recorded. |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- Installs now succeed on CPython 3.10; the package previously refused to
+  resolve there.
+- The published wheel is tagged `cp310-abi3` instead of `cp311-abi3`. It is
+  still one stable-ABI wheel per platform, loadable on every CPython from the
+  tagged version up — 3.11 through 3.14 keep installing the same artifact shape.
+- On 3.10 only, `dirsql` pulls in one new runtime dependency, `tomli>=2` (the
+  backport `tomllib` was derived from). It is not installed on 3.11+.
+
+#### Verification
+
+```console
+$ python3.10 -m pip install dirsql
+$ python3.10 -c "import dirsql; print(dirsql.__version__)"
+```
+
+```python
+# On 3.10 the config parser transparently uses the backport:
+import dirsql.resolve_config_extensions as rce
+print(rce._toml.__name__)  # -> 'tomli' on 3.10, 'tomllib' on 3.11+
+```

dirsql-0.4.2/packages/rust/changelog.d/2026-07-29-on-file-failures-accumulate.md

@@ -0,0 +1,8 @@
+**Changed** — a scan now attempts every matched file instead of stopping at the
+first whose `on-file` hook fails, and reports every failure rather than only the
+first. A single failure still raises `DirSqlError::OnFile` unchanged; several
+now raise a new `DirSqlError::OnFileMany` carrying one `OnFileFailure { path,
+message }` per file.
+
+A scan with failures still fails and still leaves the cache exactly as it was —
+only the reporting improved. Committing a partial index is tracked in #697.

{dirsql-0.4.0 → dirsql-0.4.2}/packages/rust/src/lib.rs

@@ -78,6 +78,16 @@ pub const DEFAULT_CONFIG_TOML: &str = include_str!("default_config.toml");
 type BoxError = Box<dyn StdError + Send + Sync + 'static>;
 type OnFileFn = dyn Fn(&str) -> std::result::Result<Vec<Row>, BoxError> + Send + Sync + 'static;
 
+/// One file whose on-file hook failed, carried so a scan can report every
+/// failure rather than only whichever came first.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OnFileFailure {
+    /// Path relative to the scan root.
+    pub path: String,
+    /// The hook's error, as rendered by its `Display`.
+    pub message: String,
+}
+
 #[derive(Debug, Error)]
 pub enum DirSqlError {
     #[error(transparent)]
@@ -122,6 +132,20 @@ pub enum DirSqlError {
     #[error("on-file error for {path}: {message}")]
     OnFile { path: String, message: String },
 
+    /// Several files' on-file hooks failed during one scan. A scan attempts
+    /// every matched file, so more than one can fail; reporting only the first
+    /// would make the rest invisible until it was fixed and the scan re-run.
+    #[error(
+        "{} files failed their on-file hook:\n{}",
+        .failures.len(),
+        .failures
+            .iter()
+            .map(|OnFileFailure { path, message }| format!("  {path}: {message}"))
+            .collect::<Vec<_>>()
+            .join("\n")
+    )]
+    OnFileMany { failures: Vec<OnFileFailure> },
+
     #[error("config error: {message}")]
     Config {
         message: String,
@@ -816,6 +840,7 @@ impl DirSQL {
         }
 
         let snapshot_ns = now_ns();
+        let mut on_file_failures: Vec<OnFileFailure> = Vec::new();
         for ScannedFile {
             rel_path,
             table_name,
@@ -827,11 +852,20 @@ impl DirSQL {
             })?;
             let strict = *strict_map.get(&table_name).unwrap_or(&false);
             let abs_path = root.join(&rel_path);
-            let raw_rows =
-                on_file(&abs_path.to_string_lossy()).map_err(|e| DirSqlError::OnFile {
-                    path: rel_path.clone(),
-                    message: e.to_string(),
-                })?;
+            // A hook failure is this file's problem, not the scan's: record it
+            // and keep going, so one unreadable file cannot hide the state of
+            // every file after it. The collected failures still fail the build
+            // below -- whether a partial index commits is dirsql#697.
+            let raw_rows = match on_file(&abs_path.to_string_lossy()) {
+                Ok(rows) => rows,
+                Err(e) => {
+                    on_file_failures.push(OnFileFailure {
+                        path: rel_path.clone(),
+                        message: e.to_string(),
+                    });
+                    continue;
+                }
+            };
 
             // When updating an existing file in the persistent cache, drop
             // its old rows before inserting the new ones.
@@ -870,6 +904,27 @@ impl DirSQL {
             write_meta(db.conn(), meta).map_err(DirSqlError::sqlite)?;
         }
 
+        // Returning before the commit drops `_tx`, so a scan with failures
+        // still leaves the cache exactly as it was -- the pre-existing
+        // behavior. The single-failure case keeps its original error verbatim;
+        // only the multi-failure case reports more than it used to. Whether a
+        // partial index should commit instead is dirsql#697.
+        match on_file_failures.len() {
+            0 => {}
+            1 => {
+                let only = on_file_failures.remove(0);
+                return Err(DirSqlError::OnFile {
+                    path: only.path,
+                    message: only.message,
+                });
+            }
+            _ => {
+                return Err(DirSqlError::OnFileMany {
+                    failures: on_file_failures,
+                });
+            }
+        }
+
         // Commit the ingest transaction.
         _tx.commit().map_err(DirSqlError::sqlite)?;
 

{dirsql-0.4.0 → dirsql-0.4.2}/pyproject.toml

@@ -11,13 +11,19 @@ name = "dirsql"
 dynamic = ["version"]
 description = "Ephemeral SQL index over a local directory"
 license = "MIT"
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 authors = [
     { name = "Kevin Scott" },
 ]
 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"',
+]
 
 # Dev/test dependencies live in a PEP 735 dependency-group (not a
 # `[project.optional-dependencies]` extra) so a plain `uv sync` installs them
@@ -90,7 +96,10 @@ exclude = [
 ]
 
 [tool.ty.environment]
-python-version = "3.11"
+# Tracks `requires-python`: type-check against the FLOOR so a 3.11-only symbol
+# (`tomllib`, `StrEnum`, `typing.Self`) fails here rather than at a user's
+# import on the oldest supported interpreter.
+python-version = "3.10"
 
 # ruff 0.16.0 formats Python code blocks in Markdown by default. Keep ruff
 # scoped to Python source (its effective scope under the prior pin): the README

dirsql-0.4.0/packages/python/e2e-attestations/chore-681-ruff-016.json

@@ -1,7 +0,0 @@
-{
-  "command": "just test-e2e",
-  "ran_at": 1785113998,
-  "exit_code": 0,
-  "commit": "d26765dc31e8a9e47df429bb81c0aedb05dc6a21",
-  "branch": "chore/681-ruff-016"
-}