dirsql 0.4.121__tar.gz → 0.4.123__tar.gz

{dirsql-0.4.121 → dirsql-0.4.123}/Cargo.lock

@@ -573,7 +573,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql"
-version = "0.4.121"
+version = "0.4.123"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.121"
+version = "0.4.123"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.121 → dirsql-0.4.123}/PKG-INFO

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

{dirsql-0.4.121 → dirsql-0.4.123}/dirsql/_async.py

@@ -1,6 +1,7 @@
 """Async-by-default DirSQL wrapper."""
 
 import asyncio
+import contextlib
 import os
 import weakref
 
@@ -129,11 +130,20 @@ class DirSQL:
         """Run the scan in the background."""
         try:
             self._db = await asyncio.to_thread(self._build_db)
+            if self._watch_streams:
+                await asyncio.to_thread(self._start_watcher_quietly, self._db)
         except Exception as exc:
             self._init_error = exc
         finally:
             self._ready_event.set()
 
+    @staticmethod
+    def _start_watcher_quietly(db):
+        # A watcher that cannot start is the stream's error, not init's: the
+        # stream's first iteration retries the start and raises it there.
+        with contextlib.suppress(Exception):
+            db._start_watcher()
+
     def _build_db(self):
         """Resolve extensions and construct the Rust-backed instance.
 
@@ -229,14 +239,22 @@ class DirSQL:
     def watch(self):
         """Start watching for file changes. Returns an async iterable of RowEvent.
 
-        Like :meth:`query`, the returned stream awaits :meth:`ready` on its
-        first iteration before starting the watcher, so calling ``watch``
-        before an explicit ``await db.ready()`` waits for the background scan
-        (and surfaces any initialization error) instead of failing on a
-        still-``None`` ``_db``.
+        The watcher is live once both ``watch()`` and :meth:`ready` have
+        returned, in either order: a file written after that point produces
+        an event and reaches the index. Called after the scan, ``watch()``
+        starts the watcher before returning; called before it, the watcher
+        starts before :meth:`ready` resolves. Writes made while the scan is
+        still running may be missed.
+
+        The returned stream awaits :meth:`ready` on its first iteration, so
+        iterating before an explicit ``await db.ready()`` waits for the
+        background scan and surfaces any initialization error.
 
         Each call returns an independent stream, and every stream receives
         every event observed after it was created, so several consumers
         (one per client, say) can share one instance.
         """
-        return _WatchStream(self)
+        stream = _WatchStream(self)
+        if self._db is not None:
+            self._db._start_watcher()
+        return stream

{dirsql-0.4.121 → dirsql-0.4.123}/docs/reference/sdk.md

@@ -297,9 +297,14 @@ while let Some(event) = stream.next().await { ... }
 :::
 
 Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
-under the root. The watcher starts on first iteration (Python/TypeScript)
-or at the `watch()` call (Rust). The stream never terminates on its own;
-stop consuming it to stop.
+under the root. The stream never terminates on its own; stop consuming it
+to stop.
+
+A file written once the watcher is live produces an event and reaches the
+index. Rust: the watcher is live when `watch()` returns. Python: it is live
+once both `watch()` and `ready()` have returned, in either order; a write made
+while the initial scan is still running may be missed. TypeScript: the watcher
+starts on first iteration.
 
 An instance with no named tables cannot be watched: path-tables emit no
 watch events, so `watch()` (and the polling primitives) raise an error naming

{dirsql-0.4.121 → dirsql-0.4.123}/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.121"
+version = "0.4.123"
 # 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.123/packages/python/changelog.d/2026-11-02-watch-live-on-return.md

@@ -0,0 +1 @@
+**Fixed** `watch()` now starts the watcher before it returns (or, when called before the initial scan finishes, before `ready()` resolves). A file written right after `watch()` previously produced no event and never reached the index, because the watcher only started on the stream's first iteration.

{dirsql-0.4.121/packages/rust → dirsql-0.4.123/packages/python}/docs/reference/sdk.md

@@ -297,9 +297,14 @@ while let Some(event) = stream.next().await { ... }
 :::
 
 Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
-under the root. The watcher starts on first iteration (Python/TypeScript)
-or at the `watch()` call (Rust). The stream never terminates on its own;
-stop consuming it to stop.
+under the root. The stream never terminates on its own; stop consuming it
+to stop.
+
+A file written once the watcher is live produces an event and reaches the
+index. Rust: the watcher is live when `watch()` returns. Python: it is live
+once both `watch()` and `ready()` have returned, in either order; a write made
+while the initial scan is still running may be missed. TypeScript: the watcher
+starts on first iteration.
 
 An instance with no named tables cannot be watched: path-tables emit no
 watch events, so `watch()` (and the polling primitives) raise an error naming

dirsql-0.4.123/packages/python/e2e-attestations/bot-1552-watch-gap-1102.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/extension_package_test.py tests/e2e/plugin_discovery_test.py tests/e2e/plugin_extension_discovery_test.py tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1793651115,
+  "exit_code": 0,
+  "commit": "91c319050e0960f87324c774ed7593895947fb35",
+  "branch": "bot/1552-watch-gap-1102"
+}

dirsql-0.4.123/packages/python/migrations.d/2026-11-02-watch-live-on-return.md

@@ -0,0 +1,21 @@
+### `watch()` starts the watcher before it returns
+
+#### Summary
+
+The Python `watch()` now starts the native watcher before it returns; called before the initial scan finishes, it starts the watcher before `ready()` resolves. A file written after both `watch()` and `ready()` have returned produces an event and reaches the index. Nothing breaks.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+On an instance with no named tables, `watch()` called after `ready()` raises immediately instead of on the stream's first iteration. A sleep between `watch()` and the first write is no longer needed.
+
+#### Verification
+
+`await db.ready(); stream = db.watch()`, write a matching file, then `await anext(stream)`: expect an `insert` event, and `await db.query(...)` returns the row.

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

{dirsql-0.4.121/packages/python → dirsql-0.4.123/packages/rust}/docs/reference/sdk.md

@@ -297,9 +297,14 @@ while let Some(event) = stream.next().await { ... }
 :::
 
 Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
-under the root. The watcher starts on first iteration (Python/TypeScript)
-or at the `watch()` call (Rust). The stream never terminates on its own;
-stop consuming it to stop.
+under the root. The stream never terminates on its own; stop consuming it
+to stop.
+
+A file written once the watcher is live produces an event and reaches the
+index. Rust: the watcher is live when `watch()` returns. Python: it is live
+once both `watch()` and `ready()` have returned, in either order; a write made
+while the initial scan is still running may be missed. TypeScript: the watcher
+starts on first iteration.
 
 An instance with no named tables cannot be watched: path-tables emit no
 watch events, so `watch()` (and the polling primitives) raise an error naming