rete-graph 0.2.2__tar.gz → 0.2.3__tar.gz

{rete_graph-0.2.2 → rete_graph-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rete-graph
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{rete_graph-0.2.2 → rete_graph-0.2.3}/clients/python/Cargo.lock

@@ -671,7 +671,7 @@ dependencies = [
 
 [[package]]
 name = "rete-python"
-version = "0.2.1"
+version = "0.2.3"
 dependencies = [
  "pyo3",
  "rete-core",

{rete_graph-0.2.2 → rete_graph-0.2.3}/clients/python/Cargo.toml

@@ -5,7 +5,7 @@
 name = "rete-python"
 # Keep in lockstep with pyproject.toml's [project] version — __version__
 # comes from here (CARGO_PKG_VERSION), the wheel metadata from pyproject.
-version = "0.2.1"
+version = "0.2.3"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/caviri/rete"

{rete_graph-0.2.2 → rete_graph-0.2.3}/clients/python/src/lib.rs

@@ -127,6 +127,15 @@ impl Graph {
         }
         Ok(())
     }
+
+    /// The incompleteness verdict is PER CALL on this resident handle: reset
+    /// the sticky failure flags before evaluating, so one transient network
+    /// failure fails only the call it happened in — failed tiles/chunks are
+    /// never cached, so the next call simply retries them. (Same shape as the
+    /// browser engine's RemoteGraph entry points.)
+    fn fresh_verdict(&self) {
+        self.rete.reset_load_failures();
+    }
 }
 
 #[pymethods]
@@ -143,6 +152,7 @@ impl Graph {
         graph: Option<&str>,
         format: &str,
     ) -> PyResult<String> {
+        self.fresh_verdict();
         let out = py
             .allow_threads(|| -> Result<String, String> {
                 let shapes =
@@ -169,6 +179,7 @@ impl Graph {
     /// QL entailment by query rewriting.
     #[pyo3(signature = (query, *, reason=false))]
     fn query(&self, py: Python<'_>, query: &str, reason: bool) -> PyResult<String> {
+        self.fresh_verdict();
         let out = py
             .allow_threads(|| {
                 if reason {

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/dict.rs

@@ -287,8 +287,16 @@ impl SectionChunk {
     /// The byte offset (into `data`) of each run in this chunk, computed once by
     /// scanning the decompressed body and cached. `data` must be this chunk's
     /// body. Offset 0 is the chunk's first run (chunks are run-aligned); every
-    /// `restart_interval` terms starts the next run.
+    /// `restart_interval` terms starts the next run. An EMPTY body (the
+    /// transient-fetch-failure sentinel — never a real chunk) is not cached, or
+    /// a failed chunk's empty offset table would outlive the retryable data.
     fn run_offsets(&self, data: &[u8], restart_interval: usize) -> &[usize] {
+        if let Some(r) = self.runs.get() {
+            return r;
+        }
+        if data.is_empty() {
+            return &[];
+        }
         self.runs
             .get_or_init(|| chunk_run_offsets(data, restart_interval))
     }
@@ -427,19 +435,37 @@ impl ChunkedSection {
         self.meta.term_count
     }
 
-    /// Did any chunk fetch fail since this section was opened? (Sticky.)
+    /// Did any chunk fetch fail since this section was opened — or since the
+    /// last [`reset_load_failure`](Self::reset_load_failure)?
     pub fn load_incomplete(&self) -> bool {
         self.failed.load(Ordering::Relaxed)
     }
 
+    /// Forget recorded fetch failures (see `GraphIndex::reset_load_failure` —
+    /// the per-query reset for resident sessions). Failed chunks were never
+    /// cached, so the next resolution retries them.
+    pub fn reset_load_failure(&self) {
+        self.failed.store(false, Ordering::Relaxed);
+    }
+
+    /// A FAILED fetch records the failure and returns an empty slice WITHOUT
+    /// caching it, so a later resolution retries the chunk — a transient
+    /// network error must not permanently poison a resident session.
     fn chunk_data(&self, ci: usize) -> &[u8] {
-        self.chunks[ci].data.get_or_init(|| match &self.loader {
-            Some(load) => load(ci).unwrap_or_else(|| {
-                self.failed.store(true, Ordering::Relaxed);
-                Vec::new()
-            }),
-            None => Vec::new(),
-        })
+        let cell = &self.chunks[ci].data;
+        if let Some(d) = cell.get() {
+            return d;
+        }
+        match &self.loader {
+            Some(load) => match load(ci) {
+                Some(bytes) => cell.get_or_init(|| bytes),
+                None => {
+                    self.failed.store(true, Ordering::Relaxed);
+                    &[]
+                }
+            },
+            None => cell.get_or_init(Vec::new),
+        }
     }
 
     /// The chunk holding `run` (chunks ascend by `first_run`; the first chunk

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/dictionary.rs

@@ -154,11 +154,19 @@ impl Dictionary {
         self.has_quoted_triples
     }
 
-    /// Did any lazy chunk fetch fail since this dictionary was opened?
+    /// Did any lazy chunk fetch fail since this dictionary was opened — or
+    /// since the last [`reset_load_failure`](Self::reset_load_failure)?
     pub fn load_incomplete(&self) -> bool {
         self.sections.iter().any(|s| s.load_incomplete())
     }
 
+    /// Forget recorded fetch failures across every section (see
+    /// `GraphIndex::reset_load_failure` — the per-query reset for resident
+    /// sessions). Failed chunks were never cached, so they simply retry.
+    pub fn reset_load_failure(&self) {
+        self.sections.iter().for_each(|s| s.reset_load_failure());
+    }
+
     /// Batch-fault every unloaded chunk of every section (no-op for local
     /// dictionaries). Callers about to resolve *every* term — export, dump —
     /// call this once so the sweep coalesces into a few range reads instead

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/extbuild.rs

@@ -1621,7 +1621,13 @@ mod tests {
         let tmp = TmpDir { dir: spill.clone() };
         let global_tri = spill.join("global.tri");
         let codec = crate::file::writer_codec();
-        let run_len = ((16u64 << 30) / 2 / 24) as usize;
+        // RETE_RESUME_BUDGET_MB (default 16384) sizes the sort runs — resume
+        // with a smaller budget when the machine is busier than the build was
+        let budget_mb: u64 = std::env::var("RETE_RESUME_BUDGET_MB")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(16384);
+        let run_len = ((budget_mb << 20) / 2 / 24) as usize;
 
         let mut sections = Vec::new();
         for perm in crate::index::ALL_PERMS {

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/file.rs

@@ -2408,6 +2408,21 @@ impl Rete {
             || self.named_graphs.iter().any(|(_, g)| g.load_incomplete())
     }
 
+    /// Forget recorded lazy-fetch failures — the start-of-evaluation reset for
+    /// a RESIDENT session (a browser worker holding one `Rete` across many
+    /// queries): it makes [`index_incomplete`](Self::index_incomplete) a
+    /// per-query verdict instead of a per-open one, so a single transient
+    /// network failure no longer fails every subsequent query on the session.
+    /// Sound because failed tiles/chunks are never cached — the next
+    /// evaluation simply retries the fetch.
+    pub fn reset_load_failures(&self) {
+        self.index.reset_load_failure();
+        self.dict.reset_load_failure();
+        for (_, g) in &self.named_graphs {
+            g.reset_load_failure();
+        }
+    }
+
     fn resolve_query_pattern(
         &self,
         s: Option<&str>,

rete_graph-0.2.3/crates/rete-core/src/geo3.rs

@@ -0,0 +1,207 @@
+//! A 3D extension of the GeoSPARQL built-ins (`geo3`).
+//!
+//! GeoSPARQL (see [`crate::geo`]) is planar: its `wktLiteral` parser drops the Z
+//! ordinate and every relation/distance is 2D. `geo3` adds true three-dimensional
+//! topology and distance over **axis-aligned bounding boxes** (AABBs) derived from
+//! 3D geometry literals — `POINT Z`, `MULTIPOINT Z`, `LINESTRING Z`,
+//! `POLYHEDRALSURFACE Z`, and a compact `BOX3D(minx miny minz, maxx maxy maxz)`.
+//!
+//! It is deliberately AABB-level (not exact solid geometry): that is what makes it
+//! cheap enough to evaluate inside a FILTER over a whole graph, and it is exactly
+//! the model materialised by the z-anatomy dataset. Coordinates are an abstract
+//! Cartesian 3-space in the literal's own unit (z-anatomy uses millimetres); no CRS
+//! reprojection is performed. wasm-safe: `core`/`alloc` + `f64` only.
+//!
+//! Exposed as SPARQL functions (base `https://w3id.org/rete/geo3/function/`):
+//!   * `distance3D(g1, g2)`          → xsd:double, min gap between the AABBs (0 if they meet)
+//!   * `contains3D(g1, g2)`          → xsd:boolean, AABB(g1) ⊇ AABB(g2)
+//!   * `within3D(g1, g2)`            → xsd:boolean, AABB(g1) ⊆ AABB(g2)
+//!   * `adjacent3D(g1, g2 [, gap])`  → xsd:boolean, AABBs within `gap` (default 0) on every axis
+
+/// Datatype IRI for a 3D WKT literal (`"POINT Z(x y z)"^^geo3:wktLiteral3D`).
+pub(crate) const WKT3: &str = "https://w3id.org/rete/geo3#wktLiteral3D";
+/// Datatype IRI for a bounding-box literal (`"BOX3D(...)"^^geo3:box3dLiteral`).
+pub(crate) const BOX3D: &str = "https://w3id.org/rete/geo3#box3dLiteral";
+
+const EPS: f64 = 1e-9;
+
+/// An axis-aligned 3D bounding box (a point is the degenerate `min == max`).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct Aabb {
+    pub min: [f64; 3],
+    pub max: [f64; 3],
+}
+
+/// The 3D topological relation to test.
+#[derive(Clone, Copy)]
+pub(crate) enum Rel3 {
+    Contains,
+    Within,
+    Adjacent,
+}
+
+const KEYWORDS: &[&str] = &[
+    "POINT", "MULTIPOINT", "LINESTRING", "MULTILINESTRING", "POLYGON",
+    "MULTIPOLYGON", "POLYHEDRALSURFACE", "TIN", "GEOMETRYCOLLECTION", "BOX3D",
+];
+
+/// Parse a 3D WKT / BOX3D lexical form into its AABB. A leading CRS URI
+/// (`<…> POINT Z(…)`) is stripped and ignored. Returns `None` on an unknown
+/// keyword, an EMPTY/degenerate geometry, or no finite coordinate. Coordinates
+/// are grouped by the WKT commas; nested parens are flattened (only the AABB is
+/// needed), and a coordinate's 3rd ordinate defaults to 0 if absent.
+pub(crate) fn parse(input: &str) -> Option<Aabb> {
+    let mut s = input.trim();
+    if let Some(rest) = s.strip_prefix('<') {
+        let end = rest.find('>')?;
+        s = rest[end + 1..].trim_start();
+    }
+    let open = s.find('(')?;
+    // leading token before '(' is the geometry keyword; a "Z"/"M"/"ZM" dimension
+    // tag (if any) is a separate whitespace-delimited word and is ignored.
+    let head = s[..open].trim().to_ascii_uppercase();
+    let kw = head.split_whitespace().next()?;
+    if !KEYWORDS.contains(&kw) {
+        return None;
+    }
+    let close = s.rfind(')')?;
+    if close <= open {
+        return None;
+    }
+    let body = &s[open + 1..close];
+    // flatten nested rings/parens; group coordinates by comma
+    let flat: String = body.chars().map(|c| if c == '(' || c == ')' { ' ' } else { c }).collect();
+
+    let mut mn = [f64::INFINITY; 3];
+    let mut mx = [f64::NEG_INFINITY; 3];
+    let mut any = false;
+    for group in flat.split(',') {
+        let mut ords = [0.0_f64; 3];
+        let mut nread = 0usize;
+        for tok in group.split_whitespace() {
+            if nread >= 3 {
+                break;
+            }
+            match tok.parse::<f64>() {
+                Ok(v) if v.is_finite() => {
+                    ords[nread] = v;
+                    nread += 1;
+                }
+                _ => {} // ignore an "EMPTY" token or stray text
+            }
+        }
+        if nread >= 2 {
+            for i in 0..3 {
+                mn[i] = mn[i].min(ords[i]);
+                mx[i] = mx[i].max(ords[i]);
+            }
+            any = true;
+        }
+    }
+    any.then_some(Aabb { min: mn, max: mx })
+}
+
+/// Per-axis clearance between two boxes (0 if they overlap on that axis).
+fn axis_gap(a_min: f64, a_max: f64, b_min: f64, b_max: f64) -> f64 {
+    (a_min - b_max).max(b_min - a_max).max(0.0)
+}
+
+/// Minimum Euclidean distance between the two AABBs (0 if they intersect).
+/// For point geometries this is the exact point-to-point distance.
+pub(crate) fn distance(a: &Aabb, b: &Aabb) -> f64 {
+    let mut sum = 0.0;
+    for i in 0..3 {
+        let g = axis_gap(a.min[i], a.max[i], b.min[i], b.max[i]);
+        sum += g * g;
+    }
+    sum.sqrt()
+}
+
+/// `a` contains `b`: b's box lies inside a's box on every axis (within EPS).
+fn contains(a: &Aabb, b: &Aabb) -> bool {
+    (0..3).all(|i| a.min[i] <= b.min[i] + EPS && a.max[i] >= b.max[i] - EPS)
+}
+
+/// Boxes are within `gap` on every axis (gap 0 = touching/overlapping).
+fn adjacent(a: &Aabb, b: &Aabb, gap: f64) -> bool {
+    let g = gap.max(0.0);
+    (0..3).all(|i| a.min[i] <= b.max[i] + g + EPS && a.max[i] >= b.min[i] - g - EPS)
+}
+
+/// Evaluate a 3D relation. `gap` is only used by `Adjacent`.
+pub(crate) fn relate(rel: Rel3, a: &Aabb, b: &Aabb, gap: f64) -> bool {
+    match rel {
+        Rel3::Contains => contains(a, b),
+        Rel3::Within => contains(b, a),
+        Rel3::Adjacent => adjacent(a, b, gap),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn p(s: &str) -> Aabb {
+        parse(s).unwrap()
+    }
+
+    #[test]
+    fn parse_point_box_multipoint() {
+        assert_eq!(
+            p("POINT Z(1 2 3)"),
+            Aabb { min: [1.0, 2.0, 3.0], max: [1.0, 2.0, 3.0] }
+        );
+        assert_eq!(
+            p("BOX3D(0 0 0, 10 20 30)"),
+            Aabb { min: [0.0, 0.0, 0.0], max: [10.0, 20.0, 30.0] }
+        );
+        // multipoint / linestring → bounding box over all coords
+        assert_eq!(
+            p("MULTIPOINT Z(1 1 1, 5 -2 9)"),
+            Aabb { min: [1.0, -2.0, 1.0], max: [5.0, 1.0, 9.0] }
+        );
+        // CRS prefix ignored; 2D point → z defaults to 0
+        assert_eq!(p("<urn:crs> POINT(4 5)").min, [4.0, 5.0, 0.0]);
+        // nested parens (a box-like polyhedral surface) flatten to the AABB
+        let a = p("POLYHEDRALSURFACE Z(((0 0 0, 1 0 0, 1 1 2)))");
+        assert_eq!(a.min, [0.0, 0.0, 0.0]);
+        assert_eq!(a.max, [1.0, 1.0, 2.0]);
+        assert!(parse("FOO(1 2 3)").is_none());
+        assert!(parse("POINT EMPTY").is_none());
+    }
+
+    #[test]
+    fn distance_3d() {
+        // axis-aligned separation on Z only
+        let d = distance(&p("POINT Z(0 0 0)"), &p("POINT Z(0 0 5)"));
+        assert!((d - 5.0).abs() < 1e-9);
+        // 3-4-0 -> 5 in the XY plane, plus 12 on Z -> 13
+        let d = distance(&p("POINT Z(0 0 0)"), &p("POINT Z(3 4 12)"));
+        assert!((d - 13.0).abs() < 1e-9);
+        // overlapping boxes -> 0
+        assert_eq!(
+            distance(&p("BOX3D(0 0 0, 10 10 10)"), &p("POINT Z(5 5 5)")),
+            0.0
+        );
+        // box-to-box gap on one axis
+        let d = distance(&p("BOX3D(0 0 0, 1 1 1)"), &p("BOX3D(0 0 4, 1 1 5)"));
+        assert!((d - 3.0).abs() < 1e-9);
+    }
+
+    #[test]
+    fn relations_3d() {
+        let big = p("BOX3D(0 0 0, 10 10 10)");
+        let small = p("BOX3D(2 2 2, 4 4 4)");
+        assert!(relate(Rel3::Contains, &big, &small, 0.0));
+        assert!(!relate(Rel3::Contains, &small, &big, 0.0));
+        assert!(relate(Rel3::Within, &small, &big, 0.0));
+        // adjacency: 2 mm apart on Z, not touching at gap 0 but adjacent at gap 3
+        let a = p("BOX3D(0 0 0, 1 1 1)");
+        let b = p("BOX3D(0 0 3, 1 1 4)");
+        assert!(!relate(Rel3::Adjacent, &a, &b, 0.0));
+        assert!(relate(Rel3::Adjacent, &a, &b, 3.0));
+        // touching faces are adjacent at gap 0
+        let c = p("BOX3D(1 0 0, 2 1 1)");
+        assert!(relate(Rel3::Adjacent, &a, &c, 0.0));
+    }
+}

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/index.rs

@@ -523,11 +523,22 @@ impl GraphIndex {
         self.read_concurrency
     }
 
-    /// Did any tile fetch fail since this index was opened? (Sticky.)
+    /// Did any tile fetch fail since this index was opened — or since the last
+    /// [`reset_load_failure`](Self::reset_load_failure)?
     pub fn load_incomplete(&self) -> bool {
         self.load_failed.load(std::sync::atomic::Ordering::Relaxed)
     }
 
+    /// Forget recorded fetch failures — the start-of-evaluation reset for a
+    /// RESIDENT session, making the incompleteness verdict per-query instead of
+    /// per-open (one transient network blip used to fail every later query on
+    /// the session). Safe because failed tiles are never cached: the next scan
+    /// simply retries them.
+    pub fn reset_load_failure(&self) {
+        self.load_failed
+            .store(false, std::sync::atomic::Ordering::Relaxed);
+    }
+
     /// True for a remote/lazy index (tiles fault in over a `RangeReader`). The
     /// join planner uses this to pick read-aware strategies: here a per-row index
     /// probe is a network round-trip, not a memory lookup, so a left-deep scan +
@@ -601,18 +612,27 @@ impl GraphIndex {
     }
 
     /// The tile's block image, faulting it in through the loader if remote.
+    /// A FAILED fetch records the failure and returns an empty slice WITHOUT
+    /// caching it, so a later evaluation retries the tile — a transient
+    /// network error must not permanently poison a long-lived (resident)
+    /// session with an empty tile masquerading as data.
     fn tile_data(&self, section: usize, tile: usize) -> &[u8] {
-        self.sections[section][tile].data.get_or_init(|| {
-            match &self.loader {
-                Some(load) => load(section, tile).unwrap_or_else(|| {
+        let cell = &self.sections[section][tile].data;
+        if let Some(d) = cell.get() {
+            return d;
+        }
+        match &self.loader {
+            Some(load) => match load(section, tile) {
+                Some(bytes) => cell.get_or_init(|| bytes),
+                None => {
                     self.load_failed
                         .store(true, std::sync::atomic::Ordering::Relaxed);
-                    Vec::new()
-                }),
-                // A local tile with no data was constructed empty on purpose.
-                None => Vec::new(),
-            }
-        })
+                    &[]
+                }
+            },
+            // A local tile with no data was constructed empty on purpose.
+            None => cell.get_or_init(Vec::new),
+        }
     }
 
     /// Total triple count (sum of the SPO tiles' zone counts). For a remote

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/lib.rs

@@ -19,6 +19,7 @@ pub mod dictionary;
 pub mod file;
 #[doc(hidden)]
 pub mod geo;
+pub mod geo3;
 #[doc(hidden)]
 pub mod header;
 #[doc(hidden)]

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/sparql/expr.rs

@@ -400,6 +400,17 @@ fn func_value(f: Builtin, args: &[FExpr], ctx: &Ctx, b: &Row) -> Option<Rc<str>>
                 Some(crate::geo::GEO_WKT),
             )))
         }
+        // geo3 3D relations in value position → xsd:boolean.
+        Builtin::Geo3Contains | Builtin::Geo3Within | Builtin::Geo3Adjacent => {
+            let gap = args.get(2).and_then(|e| e.value(ctx, b));
+            let r = geo3_relation(f, &a0()?, &args.get(1)?.value(ctx, b)?, gap)?;
+            Some(Rc::from(bool_literal(r)))
+        }
+        // geo3:distance3D(g1, g2) → xsd:double (min AABB gap, literal's own unit).
+        Builtin::Geo3Distance => {
+            let d = crate::geo3::distance(&geo3_arg(&a0()?)?, &geo3_arg(&args.get(1)?.value(ctx, b)?)?);
+            Some(Rc::from(make_literal(&fmt_plain(d), None, Some(XSD_DOUBLE))))
+        }
         _ => None,
     }
 }
@@ -433,6 +444,35 @@ fn geo_relation(f: Builtin, t1: &str, t2: &str) -> Option<bool> {
     crate::geo::relate(rel, &wkt_arg(t1)?, &wkt_arg(t2)?)
 }
 
+/// A 3D geometry literal (`geo3:wktLiteral3D` / `geo3:box3dLiteral`, leniently also
+/// `geo:wktLiteral` / plain string) → its AABB. `None` for any other term (type error).
+fn geo3_arg(token: &str) -> Option<crate::geo3::Aabb> {
+    if !token.starts_with('"') {
+        return None;
+    }
+    match datatype_iri(token).as_deref() {
+        Some(crate::geo3::WKT3)
+        | Some(crate::geo3::BOX3D)
+        | Some(crate::geo::GEO_WKT)
+        | Some(XSD_STRING)
+        | None => {}
+        Some(_) => return None,
+    }
+    crate::geo3::parse(&crate::terms::lexical(token))
+}
+
+/// Evaluate a geo3 relation builtin on two geometry terms (+ optional gap for adjacency).
+fn geo3_relation(f: Builtin, t1: &str, t2: &str, gap: Option<Rc<str>>) -> Option<bool> {
+    let rel = match f {
+        Builtin::Geo3Contains => crate::geo3::Rel3::Contains,
+        Builtin::Geo3Within => crate::geo3::Rel3::Within,
+        Builtin::Geo3Adjacent => crate::geo3::Rel3::Adjacent,
+        _ => return None,
+    };
+    let g = gap.and_then(|t| as_number(&t)).unwrap_or(0.0);
+    Some(crate::geo3::relate(rel, &geo3_arg(t1)?, &geo3_arg(t2)?, g))
+}
+
 /// A units IRI term (`<…/metre>` / `<…/degree>`) → [`crate::geo::Unit`].
 fn geo_unit(token: &str) -> Option<crate::geo::Unit> {
     match iri_content(token)? {
@@ -834,6 +874,13 @@ fn func_bool(f: Builtin, args: &[FExpr], ctx: &Ctx, b: &Row) -> bool {
             (Some(a), Some(c)) => geo_relation(f, &a, &c).unwrap_or(false),
             _ => false,
         },
+        // geo3 3D relations in FILTER context (a type error drops the row → false).
+        Builtin::Geo3Contains | Builtin::Geo3Within | Builtin::Geo3Adjacent => {
+            match (val(0), val(1)) {
+                (Some(a), Some(c)) => geo3_relation(f, &a, &c, val(2)).unwrap_or(false),
+                _ => false,
+            }
+        }
         _ => false,
     }
 }
@@ -1216,6 +1263,27 @@ mod tests {
             call(&ctx, Builtin::GeoDistance, &[&point, &far, "<bad-unit>"]),
             None
         );
+
+        // geo3 (3D extension): AABB topology + distance over POINT Z / BOX3D.
+        let wkt3 = |s: &str| lit(s, "https://w3id.org/rete/geo3#wktLiteral3D");
+        let box3d = |s: &str| lit(s, "https://w3id.org/rete/geo3#box3dLiteral");
+        let big = box3d("BOX3D(0 0 0, 10 10 10)");
+        let inner = box3d("BOX3D(2 2 2, 4 4 4)");
+        let p000 = wkt3("POINT Z(0 0 0)");
+        let p_far = wkt3("POINT Z(3 4 12)"); // distance 13 from origin
+        assert!(boolean(Builtin::Geo3Contains, &[&big, &inner]));
+        assert!(!boolean(Builtin::Geo3Contains, &[&inner, &big]));
+        assert!(boolean(Builtin::Geo3Within, &[&inner, &big]));
+        // adjacency: two boxes 3 apart on Z — not touching, adjacent within gap 3
+        let a = box3d("BOX3D(0 0 0, 1 1 1)");
+        let b = box3d("BOX3D(0 0 3, 1 1 4)");
+        assert!(!boolean(Builtin::Geo3Adjacent, &[&a, &b]));
+        assert!(boolean(Builtin::Geo3Adjacent, &[&a, &b, "3"]));
+        assert!(!boolean(Builtin::Geo3Adjacent, &["<iri>", &b]));
+        // distance3D → xsd:double "13"
+        let d = call(&ctx, Builtin::Geo3Distance, &[&p000, &p_far]).unwrap();
+        assert!(d.contains("13"), "distance3D result: {d}");
+        assert_eq!(call(&ctx, Builtin::Geo3Distance, &[&p000, "<iri>"]), None);
     }
 
     #[test]

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/sparql/lower.rs

@@ -754,6 +754,11 @@ fn convert_expr(e: &Expression) -> Result<FExpr, SparqlError> {
                     "http://www.opengis.net/def/function/geosparql/envelope" => {
                         Builtin::GeoEnvelope
                     }
+                    // geo3: 3D extension of GeoSPARQL (see crate::geo3).
+                    "https://w3id.org/rete/geo3/function/distance3D" => Builtin::Geo3Distance,
+                    "https://w3id.org/rete/geo3/function/contains3D" => Builtin::Geo3Contains,
+                    "https://w3id.org/rete/geo3/function/within3D" => Builtin::Geo3Within,
+                    "https://w3id.org/rete/geo3/function/adjacent3D" => Builtin::Geo3Adjacent,
                     _ => return Err(SparqlError::Unsupported("built-in function")),
                 },
                 _ => return Err(SparqlError::Unsupported("built-in function")),
@@ -1193,6 +1198,11 @@ mod tests {
             "<http://www.opengis.net/def/function/geosparql/sfEquals>(?a, ?b)",
             "<http://www.opengis.net/def/function/geosparql/distance>(?a, ?b, <http://www.opengis.net/def/uom/OGC/1.0/metre>)",
             "<http://www.opengis.net/def/function/geosparql/envelope>(?a)",
+            "<https://w3id.org/rete/geo3/function/distance3D>(?a, ?b)",
+            "<https://w3id.org/rete/geo3/function/contains3D>(?a, ?b)",
+            "<https://w3id.org/rete/geo3/function/within3D>(?a, ?b)",
+            "<https://w3id.org/rete/geo3/function/adjacent3D>(?a, ?b)",
+            "<https://w3id.org/rete/geo3/function/adjacent3D>(?a, ?b, 5)",
         ] {
             let q = format!("SELECT ({expression} AS ?result) WHERE {{ VALUES ?v {{ 1 }} }}");
             assert!(parse_select(&q).is_ok(), "{expression}");

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/src/sparql.rs

@@ -306,6 +306,11 @@ pub enum Builtin {
     GeoSfEquals,
     GeoDistance,
     GeoEnvelope,
+    // geo3 — 3D extension of GeoSPARQL (AABB topology + distance). See crate::geo3.
+    Geo3Distance,
+    Geo3Contains,
+    Geo3Within,
+    Geo3Adjacent,
     // RDF-star / SPARQL-star: construct + inspect quoted triples (`<<s p o>>`).
     /// `TRIPLE(s, p, o)` → the quoted triple term.
     TripleTerm,

rete_graph-0.2.3/crates/rete-core/tests/properties.proptest-regressions

@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 10def222df8ad092668efb9e15e965901a8c2bbac1992c1839bc373ebb7234c2 # shrinks to specs = []

{rete_graph-0.2.2 → rete_graph-0.2.3}/crates/rete-core/tests/ranged.rs

@@ -43,6 +43,10 @@ impl RecordingReader {
     fn fail_from_now(&self) {
         self.fail.store(true, Ordering::Relaxed);
     }
+    /// End the simulated outage — reads succeed again.
+    fn recover(&self) {
+        self.fail.store(false, Ordering::Relaxed);
+    }
 }
 
 impl RangeReader for RecordingReader {
@@ -572,6 +576,52 @@ fn lazy_sparql_open_surfaces_failed_tile_fetches() {
     );
 }
 
+/// The incompleteness verdict is PER QUERY for a resident session: after the
+/// network recovers, `reset_load_failures` clears the sticky flag and the same
+/// query RE-FETCHES what failed (failed tiles/chunks are never cached as
+/// empty), returning the complete answer — one transient blip must not poison
+/// every later query on a long-lived handle (the browser worker's session).
+#[test]
+fn reset_load_failures_makes_failed_fetches_retryable() {
+    let image = multi_tile_image();
+    let expected = {
+        // The complete answer, computed over a healthy session.
+        let healthy = Rete::open_ranged_lazy(std::sync::Arc::new(RecordingReader::new(
+            image.clone(),
+        )))
+        .unwrap();
+        let q = format!("SELECT ?o WHERE {{ {} <http://ex/knows> ?o }}", mt_node(7));
+        match eval_query(&healthy, &q).unwrap() {
+            QueryOutput::Select(_, rows) => rows.len(),
+            _ => unreachable!(),
+        }
+    };
+    assert!(expected > 0, "fixture must produce rows");
+
+    let reader = std::sync::Arc::new(RecordingReader::new(image));
+    let rete = Rete::open_ranged_lazy(reader.clone()).unwrap();
+    reader.fail_from_now();
+    let q = format!("SELECT ?o WHERE {{ {} <http://ex/knows> ?o }}", mt_node(7));
+    let _ = eval_query(&rete, &q).unwrap();
+    assert!(rete.index_incomplete(), "outage query must be flagged");
+
+    reader.recover();
+    rete.reset_load_failures();
+    assert!(!rete.index_incomplete(), "reset must clear the verdict");
+    let rows = match eval_query(&rete, &q).unwrap() {
+        QueryOutput::Select(_, rows) => rows.len(),
+        _ => unreachable!(),
+    };
+    assert!(
+        !rete.index_incomplete(),
+        "recovered query must not re-flag — its fetches succeeded"
+    );
+    assert_eq!(
+        rows, expected,
+        "the retried query must return the COMPLETE answer, not a poisoned empty tile"
+    );
+}
+
 #[test]
 fn routed_pattern_query_with_unknown_term_skips_the_index() {
     let image = image_with_pyramid();

{rete_graph-0.2.2 → rete_graph-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rete-graph"
-version = "0.2.2"
+version = "0.2.3"
 description = "Query local and remote .rete graph files with SPARQL — Python bindings for the rete engine."
 readme = "README.md"
 requires-python = ">=3.9"