dirsql 0.4.4__tar.gz → 0.4.6__tar.gz

{dirsql-0.4.4 → dirsql-0.4.6}/Cargo.lock

@@ -473,7 +473,6 @@ dependencies = [
  "libc",
  "notify",
  "predicates",
- "regex",
  "reqwest",
  "rusqlite",
  "serde",
@@ -500,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.4"
+version = "0.4.6"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.4 → dirsql-0.4.6}/PKG-INFO

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

{dirsql-0.4.4 → dirsql-0.4.6}/dirsql/_async.py

@@ -182,6 +182,23 @@ class DirSQL:
         assert db is not None  # ready() returned, so _init_bg set _db
         return await asyncio.to_thread(db.query, sql)
 
+    async def scan_failures(self):
+        """The files the initial scan could not index.
+
+        Each entry carries ``path`` (relative to the root) and ``message``
+        (the hook's own error). Empty after a clean scan, which is the signal
+        to check: a non-empty list means the index is *incomplete*, not wrong,
+        and those files are retried on the next scan.
+
+        Awaits :meth:`ready` first, so the scan has finished before the answer
+        is read -- otherwise a caller could see an empty list simply because
+        the scan had not reached the failing file yet.
+        """
+        await self.ready()
+        db = self._db
+        assert db is not None  # ready() returned, so _init_bg set _db
+        return db.scan_failures()
+
     def watch(self):
         """Start watching for file changes. Returns an async iterable of RowEvent.
 

{dirsql-0.4.4 → dirsql-0.4.6}/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.4"
+version = "0.4.6"
 # 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.6/packages/python/changelog.d/2026-08-02-scan-failures.md

@@ -0,0 +1,18 @@
+**Added**
+
+`await db.scan_failures()` returns the files the initial scan could not index —
+a list of `ScanFailure`, each with `path` (relative to the root) and `message`
+(the hook's own error). Empty after a clean scan (#715).
+
+This closes a gap opened by #714. A file whose `on_file` hook raises, or whose
+row the table rejects under `strict`, is skipped rather than failing the scan —
+so a Python caller who previously got an exception got nothing at all: a
+database quietly holding fewer rows, with no way to ask which files were
+dropped. `scan_failures()` is that way.
+
+It reports; it does not gate. The rows that did land are unaffected, and a
+skipped file never enters the persistent index, so it is retried on the next
+scan — the index is incomplete, never wrong.
+
+Awaits `ready()` first, so an empty list means the scan finished cleanly rather
+than that it had not yet reached the failing file.

dirsql-0.4.6/packages/python/e2e-attestations/claude-715-binding-scan-failures.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785678666,
+  "exit_code": 0,
+  "commit": "7de7557be856f19685344a4118e1ead9e4bae405",
+  "branch": "claude/715-binding-scan-failures"
+}

dirsql-0.4.6/packages/python/e2e-attestations/claude-716-drop-regex.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785679612,
+  "exit_code": 0,
+  "commit": "f24a5f661d5538bc5f3ef27a266fac7cc1e955ad",
+  "branch": "claude/716-drop-regex"
+}

{dirsql-0.4.4 → dirsql-0.4.6}/packages/python/src/lib.rs

@@ -97,6 +97,31 @@ mod python {
         }
     }
 
+    /// One file the initial scan could not index, with the hook's own error.
+    ///
+    /// A scan failure is not a scan *error*: the other files are indexed and
+    /// the database is usable. This is how a caller learns the index is
+    /// incomplete, and which files are missing from it.
+    #[pyclass(name = "ScanFailure", frozen)]
+    struct PyScanFailure {
+        /// Path relative to the scan root.
+        #[pyo3(get)]
+        path: String,
+        /// The hook's error, as it rendered it.
+        #[pyo3(get)]
+        message: String,
+    }
+
+    #[pymethods]
+    impl PyScanFailure {
+        fn __repr__(&self) -> String {
+            format!(
+                "ScanFailure(path={:?}, message={:?})",
+                self.path, self.message
+            )
+        }
+    }
+
     /// Synchronous binding class. `dirsql._async.DirSQL` wraps it with
     /// `asyncio.to_thread` to produce the async public API.
     #[pyclass(name = "DirSQL")]
@@ -179,6 +204,17 @@ mod python {
             Ok(list.unbind())
         }
 
+        fn scan_failures(&self) -> Vec<PyScanFailure> {
+            self.inner
+                .scan_failures()
+                .iter()
+                .map(|f| PyScanFailure {
+                    path: f.path.clone(),
+                    message: f.message.clone(),
+                })
+                .collect()
+        }
+
         fn _start_watcher(&self, py: Python<'_>) -> PyResult<()> {
             let db = self.inner.clone();
             py.detach(move || db.start_watching()).map_err(to_py_err)
@@ -415,6 +451,7 @@ mod python {
         m.add_class::<PyTable>()?;
         m.add_class::<PyDirSQL>()?;
         m.add_class::<PyRowEvent>()?;
+        m.add_class::<PyScanFailure>()?;
         Ok(())
     }
 

{dirsql-0.4.4 → dirsql-0.4.6}/packages/rust/Cargo.toml

@@ -56,7 +56,6 @@ futures = { version = "0.3", optional = true }
 futures-channel.workspace = true
 globset = "0.4"
 notify = "7"
-regex.workspace = true
 rusqlite = { version = "0.34", features = ["bundled", "load_extension", "hooks", "vtab"] }
 serde.workspace = true
 serde_json.workspace = true

dirsql-0.4.6/packages/rust/changelog.d/2026-08-02-drop-regex.md

@@ -0,0 +1,17 @@
+**Changed** — the `regex` dependency is gone. `matcher.rs` used it for one
+trivial pattern (`{name}` placeholder extraction in path templates); that is now
+a hand-rolled scan over the same grammar, `{` `[a-zA-Z_][a-zA-Z0-9_]*` `}`.
+
+Dropping the `regex` facade lets cargo drop the `regex-automata` features
+`globset` does not need, shrinking every published artifact by ~570 KB
+(CLI 6.14 -> 5.57 MB, pyo3 `.so` 4.99 -> 4.42 MB, napi `.node` 5.05 -> 4.48 MB;
+~9-11% each, on top of the release-profile change).
+
+Matcher construction also gets ~28x faster, since a `TableMatcher` no longer
+compiles two regexes per pattern: 23.8 us -> 0.87 us for one pattern,
+1.38 ms -> 47.8 us for fifty. Match throughput is unchanged (`globset` does the
+matching).
+
+No behavior change: `placeholder_names` keeps its signature and its exact
+grammar, verified against the previous regex over 2,830 inputs with zero
+mismatches.

{dirsql-0.4.4 → dirsql-0.4.6}/packages/rust/src/matcher.rs

@@ -1,5 +1,4 @@
 use globset::{Glob, GlobSet, GlobSetBuilder};
-use regex::Regex;
 use std::path::Path;
 
 /// Result of matching a file path against a glob pattern.
@@ -25,19 +24,62 @@ pub struct TableMatcher {
     ignore_set: GlobSet,
 }
 
+/// Byte spans of the `{name}` placeholders in `pattern`, in order: `(start,
+/// end, name)` with `end` past the closing brace.
+///
+/// The grammar is exactly `{` `[a-zA-Z_][a-zA-Z0-9_]*` `}`. Anything else --
+/// `{}`, `{1a}`, `{a-b}`, an unclosed `{` -- is not a placeholder and is left
+/// alone, matching the leftmost-first, non-overlapping scan the equivalent
+/// regex performed.
+fn placeholder_spans(pattern: &str) -> Vec<(usize, usize, String)> {
+    let bytes = pattern.as_bytes();
+    let mut spans = Vec::new();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'{' {
+            let mut j = i + 1;
+            if j < bytes.len() && (bytes[j].is_ascii_alphabetic() || bytes[j] == b'_') {
+                j += 1;
+                while j < bytes.len() && (bytes[j].is_ascii_alphanumeric() || bytes[j] == b'_') {
+                    j += 1;
+                }
+                if j < bytes.len() && bytes[j] == b'}' {
+                    // Every byte in `i..=j` is ASCII, so these are char boundaries.
+                    spans.push((i, j + 1, pattern[i + 1..j].to_string()));
+                    i = j + 1;
+                    continue;
+                }
+            }
+        }
+        i += 1;
+    }
+    spans
+}
+
 /// Names of the `{name}` placeholders in `pattern`, in order of appearance.
 pub fn placeholder_names(pattern: &str) -> Vec<String> {
-    let re = Regex::new(r"\{([a-zA-Z_][a-zA-Z0-9_]*)\}").unwrap();
-    re.captures_iter(pattern)
-        .map(|cap| cap[1].to_string())
+    placeholder_spans(pattern)
+        .into_iter()
+        .map(|(_, _, name)| name)
         .collect()
 }
 
 /// Rewrite `{name}` placeholders in a glob to `*`, so they match a single path
 /// segment without producing any captured value.
 fn glob_with_placeholders_as_star(pattern: &str) -> String {
-    let re = Regex::new(r"\{([a-zA-Z_][a-zA-Z0-9_]*)\}").unwrap();
-    re.replace_all(pattern, "*").into_owned()
+    let spans = placeholder_spans(pattern);
+    if spans.is_empty() {
+        return pattern.to_string();
+    }
+    let mut out = String::with_capacity(pattern.len());
+    let mut last = 0;
+    for (start, end, _) in spans {
+        out.push_str(&pattern[last..start]);
+        out.push('*');
+        last = end;
+    }
+    out.push_str(&pattern[last..]);
+    out
 }
 
 impl TableMatcher {