lora-python 0.10.1__tar.gz → 0.11.0__tar.gz

{lora_python-0.10.1 → lora_python-0.11.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "lora-ast",
  "lora-parser",
@@ -783,14 +783,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -798,7 +798,7 @@ dependencies = [
 
 [[package]]
 name = "lora-compiler"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -807,7 +807,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -830,7 +830,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -852,7 +852,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -864,7 +864,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -879,7 +879,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -890,7 +890,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -902,7 +902,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -915,7 +915,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -929,7 +929,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -943,7 +943,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -954,7 +954,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -964,7 +964,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -980,7 +980,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.10.1 → lora_python-0.11.0}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.10.1"
+version = "0.11.0"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,16 +15,16 @@ rust-version = "1.87"
 # Internal crates — versions are kept in lockstep with [workspace.package].version
 # by `scripts/sync-versions.mjs`. Both `path` and `version` are set so that
 # `cargo publish` works (crates.io cannot resolve path-only deps).
-lora-ast = { path = "crates/lora-ast", version = "=0.10.1" }
-lora-parser = { path = "crates/lora-parser", version = "=0.10.1" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.10.1" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.10.1" }
-lora-store = { path = "crates/lora-store", version = "=0.10.1" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.10.1", default-features = false }
-lora-wal = { path = "crates/lora-wal", version = "=0.10.1" }
-lora-executor = { path = "crates/lora-executor", version = "=0.10.1", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.10.1" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.10.1" }
+lora-ast = { path = "crates/lora-ast", version = "=0.11.0" }
+lora-parser = { path = "crates/lora-parser", version = "=0.11.0" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.11.0" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.11.0" }
+lora-store = { path = "crates/lora-store", version = "=0.11.0" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.11.0", default-features = false }
+lora-wal = { path = "crates/lora-wal", version = "=0.11.0" }
+lora-executor = { path = "crates/lora-executor", version = "=0.11.0", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.11.0" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.11.0" }
 
 # External crates.
 anyhow = "1"

{lora_python-0.10.1 → lora_python-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lora-python
-Version: 0.10.1
+Version: 0.11.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8

lora_python-0.11.0/crates/lora-database/tests/docs_examples.rs

@@ -0,0 +1,65 @@
+use std::path::Path;
+
+use lora_database::{Database, ExecuteOptions, InMemoryGraph, ResultFormat};
+
+fn extract_query_examples(markdown: &str) -> Vec<String> {
+    let mut examples = Vec::new();
+    let mut rest = markdown;
+    let marker = "<QueryCodeBlock code={String.raw`";
+
+    while let Some(start) = rest.find(marker) {
+        let body_start = start + marker.len();
+        let body = &rest[body_start..];
+        let Some(end) = body.find("`} />") else {
+            panic!("unterminated QueryCodeBlock in examples documentation");
+        };
+        examples.push(body[..end].to_string());
+        rest = &body[end + "`} />".len()..];
+    }
+
+    examples
+}
+
+fn execute(db: &Database<InMemoryGraph>, query: &str) {
+    db.execute(
+        query,
+        Some(ExecuteOptions {
+            format: ResultFormat::Rows,
+        }),
+    )
+    .unwrap_or_else(|err| panic!("documentation query failed:\n{query}\n\nerror: {err}"));
+}
+
+#[test]
+fn query_examples_run_against_documented_seed_graph() {
+    let docs_path = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("../../apps/loradb.com/docs/queries/examples.md");
+    let markdown = std::fs::read_to_string(&docs_path).unwrap_or_else(|err| {
+        panic!("failed to read {}: {err}", docs_path.display());
+    });
+    let examples = extract_query_examples(&markdown);
+
+    assert!(
+        examples.len() > 20,
+        "expected the examples page to contain runnable QueryCodeBlock snippets"
+    );
+
+    let seed = &examples[0];
+    execute(&Database::in_memory(), seed);
+
+    for (index, query) in examples.iter().enumerate().skip(1) {
+        let db = Database::in_memory();
+        execute(&db, seed);
+        db.execute(
+            query,
+            Some(ExecuteOptions {
+                format: ResultFormat::Rows,
+            }),
+        )
+        .unwrap_or_else(|err| {
+            panic!(
+                "documentation query #{index} failed against the seed graph:\n{query}\n\nerror: {err}"
+            )
+        });
+    }
+}

{lora_python-0.10.1 → lora_python-0.11.0}/crates/lora-wal/src/lock.rs

@@ -7,11 +7,21 @@
 use std::fs::{File, OpenOptions};
 use std::io;
 use std::path::Path;
+use std::time::{Duration, Instant};
 
 use crate::errors::WalError;
 
 const LOCK_FILE_NAME: &str = ".lora-wal.lock";
 
+/// Brief window for swallowing transient `EWOULDBLOCK` between a clean
+/// drop and a subsequent re-open of the same directory. Under load on
+/// Linux we have observed the close+flock-release of the previous
+/// owner racing with a new `flock()` attempt; a few short retries
+/// absorb that without weakening the invariant — a real concurrent
+/// owner still surfaces as `AlreadyOpen` after the window elapses.
+const ACQUIRE_RETRY_BUDGET: Duration = Duration::from_millis(100);
+const ACQUIRE_RETRY_INITIAL_BACKOFF: Duration = Duration::from_micros(100);
+
 /// RAII guard for a WAL directory lock.
 pub(crate) struct DirLock {
     _file: File,
@@ -31,14 +41,8 @@ impl DirLock {
                 .create(true)
                 .truncate(false)
                 .open(&lock_path)?;
-            lock_exclusive_nonblocking(&file).map_err(|err| {
-                if err.kind() == io::ErrorKind::WouldBlock {
-                    WalError::AlreadyOpen {
-                        dir: dir.to_path_buf(),
-                    }
-                } else {
-                    WalError::Io(err)
-                }
+            retry_on_contention(dir, || {
+                lock_exclusive_nonblocking(&file).map_err(classify_unix_lock_err)
             })?;
             Ok(Self { _file: file })
         }
@@ -51,14 +55,8 @@ impl DirLock {
                 .create(true)
                 .truncate(false)
                 .open(&lock_path)?;
-            lock_exclusive_nonblocking(&file).map_err(|err| {
-                if is_windows_lock_conflict(&err) {
-                    WalError::AlreadyOpen {
-                        dir: dir.to_path_buf(),
-                    }
-                } else {
-                    WalError::Io(err)
-                }
+            retry_on_contention(dir, || {
+                lock_exclusive_nonblocking(&file).map_err(classify_windows_lock_err)
             })?;
             Ok(Self { _file: file })
         }
@@ -70,22 +68,79 @@ impl DirLock {
             // LoraDB handles from opening the same WAL concurrently, although
             // a process crash can leave a stale lock file that operators must
             // remove manually.
-            match OpenOptions::new()
-                .read(true)
-                .write(true)
-                .create_new(true)
-                .open(&lock_path)
-            {
-                Ok(file) => Ok(Self {
-                    _file: file,
-                    path: lock_path,
-                }),
-                Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {
-                    Err(WalError::AlreadyOpen {
-                        dir: dir.to_path_buf(),
+            let file = retry_on_contention(dir, || {
+                OpenOptions::new()
+                    .read(true)
+                    .write(true)
+                    .create_new(true)
+                    .open(&lock_path)
+                    .map_err(|err| {
+                        if err.kind() == io::ErrorKind::AlreadyExists {
+                            LockAttemptError::Contended
+                        } else {
+                            LockAttemptError::Io(err)
+                        }
                     })
+            })?;
+            Ok(Self {
+                _file: file,
+                path: lock_path,
+            })
+        }
+    }
+}
+
+/// Result of a single platform-specific lock attempt, classified so the
+/// retry helper can distinguish "another live owner" (try again, briefly)
+/// from real I/O errors (fail immediately).
+enum LockAttemptError {
+    Contended,
+    Io(io::Error),
+}
+
+#[cfg(unix)]
+fn classify_unix_lock_err(err: io::Error) -> LockAttemptError {
+    if err.kind() == io::ErrorKind::WouldBlock {
+        LockAttemptError::Contended
+    } else {
+        LockAttemptError::Io(err)
+    }
+}
+
+#[cfg(windows)]
+fn classify_windows_lock_err(err: io::Error) -> LockAttemptError {
+    if is_windows_lock_conflict(&err) {
+        LockAttemptError::Contended
+    } else {
+        LockAttemptError::Io(err)
+    }
+}
+
+/// Run `attempt` repeatedly until it succeeds, returns a non-contention
+/// I/O error, or the retry budget is exhausted. Contention is the
+/// expected signal "another live owner" — under load on Linux we have
+/// observed the close+flock-release of a previous owner racing with a
+/// new `flock()` attempt; a short retry window absorbs that without
+/// weakening the invariant. A real concurrent owner persists past the
+/// window and surfaces as `AlreadyOpen` to the caller.
+fn retry_on_contention<T, F>(dir: &Path, mut attempt: F) -> Result<T, WalError>
+where
+    F: FnMut() -> Result<T, LockAttemptError>,
+{
+    let start = Instant::now();
+    let mut backoff = ACQUIRE_RETRY_INITIAL_BACKOFF;
+    loop {
+        match attempt() {
+            Ok(value) => return Ok(value),
+            Err(LockAttemptError::Io(err)) => return Err(WalError::Io(err)),
+            Err(LockAttemptError::Contended) => {
+                if start.elapsed() >= ACQUIRE_RETRY_BUDGET {
+                    return Err(WalError::AlreadyOpen {
+                        dir: dir.to_path_buf(),
+                    });
                 }
-                Err(err) => Err(WalError::Io(err)),
+                std::thread::sleep(backoff);
+                backoff = (backoff * 2).min(Duration::from_millis(5));
             }
         }
     }

{lora_python-0.10.1 → lora_python-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "lora-python"
-version = "0.10.1"
+version = "0.11.0"
 description = "Python bindings for the Lora in-memory graph database"
 readme = "README.md"
 license = { text = "BUSL-1.1" }