sqlitegraph 0.1.1__tar.gz → 0.2.0__tar.gz

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/Cargo.lock

@@ -1387,7 +1387,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "sqlitegraph"
-version = "2.2.5"
+version = "2.3.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1428,7 +1428,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-py"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "ndarray 0.16.1",
  "numpy",

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlitegraph
-Version: 0.1.1
+Version: 0.2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlitegraph"
-version = "0.1.1"
+version = "0.2.0"
 description = "Embedded graph database with HNSW vector search — Python bindings to the sqlitegraph Rust crate."
 license = { text = "GPL-3.0-only" }
 authors = [{ name = "Luiz Spies" }]

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph"
-version = "2.2.5"
+version = "2.3.0"
 edition = "2024"
 description = "Embedded graph database with full ACID transactions, HNSW vector search, dual backend support, and comprehensive graph algorithms library"
 license = "GPL-3.0"

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-core/src/backend/native/v3/backend.rs

@@ -1237,6 +1237,33 @@ impl GraphBackend for V3Backend {
         self.k_hop(_snapshot_id, _start, _depth, _direction)
     }
 
+    fn bfs_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        depth: u32,
+        _direction: BackendDirection,
+        _allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        // TODO: Implement edge type filtering for V3 backend.
+        // V3's edge_store exposes `neighbors_filtered`, but typed-edge traversal
+        // is not yet wired into the BFS path. Tracked alongside `k_hop_filtered`.
+        // For now, delegate to unfiltered bfs to match the existing stub pattern.
+        self.bfs(snapshot_id, start, depth)
+    }
+
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        end: i64,
+        _allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+        // TODO: Implement edge type filtering for V3 backend.
+        // See note on `bfs_filtered`.
+        self.shortest_path(snapshot_id, start, end)
+    }
+
     fn chain_query(
         &self,
         _snapshot_id: SnapshotId,

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-core/src/backend/sqlite/impl_.rs

@@ -10,7 +10,7 @@ use crate::{
     SqliteGraphError,
     backend::sqlite::types::{BackendDirection, EdgeSpec, NeighborQuery, NodeSpec},
     backend::{PubSubEvent, SubscriptionFilter},
-    bfs::{bfs_neighbors, shortest_path},
+    bfs::{bfs_neighbors, bfs_neighbors_filtered, shortest_path, shortest_path_filtered},
     graph::{GraphEdge, GraphEntity, SqliteGraph},
     multi_hop,
     pattern::{self, PatternMatch, PatternQuery},
@@ -427,6 +427,29 @@ impl crate::backend::GraphBackend for SqliteGraphBackend {
         Ok(result)
     }
 
+    fn bfs_filtered(
+        &self,
+        snapshot_id: crate::snapshot::SnapshotId,
+        start: i64,
+        depth: u32,
+        direction: BackendDirection,
+        allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        validate_snapshot_for_sqlite(snapshot_id)?;
+        bfs_neighbors_filtered(&self.graph, start, depth, allowed_edge_types, direction)
+    }
+
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: crate::snapshot::SnapshotId,
+        start: i64,
+        end: i64,
+        allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+        validate_snapshot_for_sqlite(snapshot_id)?;
+        shortest_path_filtered(&self.graph, start, end, allowed_edge_types)
+    }
+
     fn chain_query(
         &self,
         snapshot_id: crate::snapshot::SnapshotId,

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-core/src/backend.rs

@@ -250,6 +250,21 @@ pub trait GraphBackend {
         direction: BackendDirection,
         allowed_edge_types: &[&str],
     ) -> Result<Vec<i64>, SqliteGraphError>;
+    fn bfs_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        depth: u32,
+        direction: BackendDirection,
+        allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError>;
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        end: i64,
+        allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError>;
     fn chain_query(
         &self,
         snapshot_id: SnapshotId,
@@ -606,6 +621,27 @@ where
         (*self).k_hop_filtered(snapshot_id, start, depth, direction, allowed_edge_types)
     }
 
+    fn bfs_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        depth: u32,
+        direction: BackendDirection,
+        allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        (*self).bfs_filtered(snapshot_id, start, depth, direction, allowed_edge_types)
+    }
+
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        end: i64,
+        allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+        (*self).shortest_path_filtered(snapshot_id, start, end, allowed_edge_types)
+    }
+
     fn chain_query(
         &self,
         snapshot_id: SnapshotId,

sqlitegraph-0.2.0/sqlitegraph-core/src/bfs.rs

@@ -0,0 +1,171 @@
+use std::collections::VecDeque;
+
+use ahash::{AHashMap, AHashSet};
+
+use crate::{
+    backend::BackendDirection,
+    errors::SqliteGraphError,
+    graph::SqliteGraph,
+    multi_hop::{build_lookup, typed_adjacency},
+};
+
+pub fn bfs_neighbors(
+    graph: &SqliteGraph,
+    start: i64,
+    max_depth: u32,
+) -> Result<Vec<i64>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    let mut visited = Vec::new();
+    let mut seen = AHashSet::new();
+    let mut queue = VecDeque::new();
+    queue.push_back((start, 0));
+    seen.insert(start);
+    while let Some((node, depth)) = queue.pop_front() {
+        visited.push(node);
+        if depth >= max_depth {
+            continue;
+        }
+        for next in graph.fetch_outgoing(node)? {
+            if seen.insert(next) {
+                queue.push_back((next, depth + 1));
+            }
+        }
+    }
+    Ok(visited)
+}
+
+pub fn bfs_neighbors_filtered(
+    graph: &SqliteGraph,
+    start: i64,
+    max_depth: u32,
+    allowed_edge_types: &[&str],
+    direction: BackendDirection,
+) -> Result<Vec<i64>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    if allowed_edge_types.is_empty() {
+        return Ok(Vec::new());
+    }
+    let lookup = build_lookup(allowed_edge_types);
+    let mut visited = Vec::new();
+    let mut seen = AHashSet::new();
+    let mut queue = VecDeque::new();
+    queue.push_back((start, 0));
+    seen.insert(start);
+    while let Some((node, depth)) = queue.pop_front() {
+        visited.push(node);
+        if depth >= max_depth {
+            continue;
+        }
+        for next in typed_adjacency(graph, node, direction, Some(&lookup))? {
+            if seen.insert(next) {
+                queue.push_back((next, depth + 1));
+            }
+        }
+    }
+    Ok(visited)
+}
+
+pub fn shortest_path(
+    graph: &SqliteGraph,
+    start: i64,
+    end: i64,
+) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    graph.get_entity(end)?;
+    if start == end {
+        return Ok(Some(vec![start]));
+    }
+    let mut queue = VecDeque::new();
+    let mut parents = AHashMap::new();
+    let mut seen = AHashSet::new();
+    queue.push_back(start);
+    seen.insert(start);
+    let mut found = false;
+    while let Some(node) = queue.pop_front() {
+        for next in graph.fetch_outgoing(node)? {
+            if seen.insert(next) {
+                parents.insert(next, node);
+                if next == end {
+                    found = true;
+                    break;
+                }
+                queue.push_back(next);
+            }
+        }
+        if found {
+            break;
+        }
+    }
+    if !found {
+        return Ok(None);
+    }
+    let mut path = vec![end];
+    let mut current = end;
+    while let Some(&parent) = parents.get(&current) {
+        path.push(parent);
+        if parent == start {
+            break;
+        }
+        current = parent;
+    }
+    if path.last().map(|last| *last != start).unwrap_or(true) {
+        return Ok(None);
+    }
+    path.reverse();
+    Ok(Some(path))
+}
+
+pub fn shortest_path_filtered(
+    graph: &SqliteGraph,
+    start: i64,
+    end: i64,
+    allowed_edge_types: &[&str],
+) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    graph.get_entity(end)?;
+    if start == end {
+        return Ok(Some(vec![start]));
+    }
+    if allowed_edge_types.is_empty() {
+        return Ok(None);
+    }
+    let lookup = build_lookup(allowed_edge_types);
+    let mut queue = VecDeque::new();
+    let mut parents = AHashMap::new();
+    let mut seen = AHashSet::new();
+    queue.push_back(start);
+    seen.insert(start);
+    let mut found = false;
+    while let Some(node) = queue.pop_front() {
+        for next in typed_adjacency(graph, node, BackendDirection::Outgoing, Some(&lookup))? {
+            if seen.insert(next) {
+                parents.insert(next, node);
+                if next == end {
+                    found = true;
+                    break;
+                }
+                queue.push_back(next);
+            }
+        }
+        if found {
+            break;
+        }
+    }
+    if !found {
+        return Ok(None);
+    }
+    let mut path = vec![end];
+    let mut current = end;
+    while let Some(&parent) = parents.get(&current) {
+        path.push(parent);
+        if parent == start {
+            break;
+        }
+        current = parent;
+    }
+    if path.last().map(|last| *last != start).unwrap_or(true) {
+        return Ok(None);
+    }
+    path.reverse();
+    Ok(Some(path))
+}

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-core/src/multi_hop.rs

@@ -139,6 +139,15 @@ fn adjacency_for(
     node: i64,
     direction: BackendDirection,
     allowed_types: Option<&AHashSet<&str>>,
+) -> Result<Vec<i64>, SqliteGraphError> {
+    typed_adjacency(graph, node, direction, allowed_types)
+}
+
+pub(crate) fn typed_adjacency(
+    graph: &SqliteGraph,
+    node: i64,
+    direction: BackendDirection,
+    allowed_types: Option<&AHashSet<&str>>,
 ) -> Result<Vec<i64>, SqliteGraphError> {
     match allowed_types {
         Some(set) => filter_neighbors(graph, node, direction, set),
@@ -183,7 +192,7 @@ fn filter_neighbors(
     Ok(result)
 }
 
-fn build_lookup<'a>(types: &'a [&'a str]) -> AHashSet<&'a str> {
+pub(crate) fn build_lookup<'a>(types: &'a [&'a str]) -> AHashSet<&'a str> {
     let mut lookup = AHashSet::with_capacity(types.len());
     for ty in types {
         lookup.insert(*ty);

sqlitegraph-0.2.0/sqlitegraph-core/tests/bfs_tests.rs

@@ -0,0 +1,226 @@
+use serde_json::json;
+use sqlitegraph::{
+    GraphEdge, GraphEntity, SqliteGraph,
+    backend::BackendDirection,
+    bfs::{bfs_neighbors, bfs_neighbors_filtered, shortest_path, shortest_path_filtered},
+};
+
+fn build_graph(edges: &[(i64, i64)]) -> SqliteGraph {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    for idx in 0..10 {
+        let name = format!("node_{idx}");
+        graph
+            .insert_entity(&GraphEntity {
+                id: 0,
+                kind: "Node".to_string(),
+                name,
+                file_path: None,
+                data: json!({}),
+            })
+            .unwrap();
+    }
+    for &(from, to) in edges {
+        graph
+            .insert_edge(&GraphEdge {
+                id: 0,
+                from_id: from,
+                to_id: to,
+                edge_type: "LINK".to_string(),
+                data: json!({}),
+            })
+            .unwrap();
+    }
+    graph
+}
+
+fn build_typed_graph(edges: &[(i64, i64, &str)]) -> SqliteGraph {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    for idx in 0..10 {
+        let name = format!("node_{idx}");
+        graph
+            .insert_entity(&GraphEntity {
+                id: 0,
+                kind: "Node".to_string(),
+                name,
+                file_path: None,
+                data: json!({}),
+            })
+            .unwrap();
+    }
+    for &(from, to, edge_type) in edges {
+        graph
+            .insert_edge(&GraphEdge {
+                id: 0,
+                from_id: from,
+                to_id: to,
+                edge_type: edge_type.to_string(),
+                data: json!({}),
+            })
+            .unwrap();
+    }
+    graph
+}
+
+#[test]
+fn test_bfs_traversal_single_component() {
+    let edges = vec![(1, 2), (2, 3), (3, 4), (4, 5)];
+    let graph = build_graph(&edges);
+    let visited = bfs_neighbors(&graph, 1, 10).expect("bfs");
+    assert_eq!(visited, vec![1, 2, 3, 4, 5]);
+}
+
+#[test]
+fn test_bfs_traversal_disconnected_graph() {
+    let edges = vec![(1, 2), (2, 3), (6, 7)];
+    let graph = build_graph(&edges);
+    let visited = bfs_neighbors(&graph, 6, 10).expect("bfs");
+    assert_eq!(visited, vec![6, 7]);
+}
+
+#[test]
+fn test_shortest_path_exists() {
+    let edges = vec![(1, 2), (2, 3), (1, 4), (4, 3)];
+    let graph = build_graph(&edges);
+    let path = shortest_path(&graph, 1, 3).expect("shortest");
+    assert_eq!(path, Some(vec![1, 2, 3]));
+}
+
+#[test]
+fn test_shortest_path_not_exists() {
+    let edges = vec![(1, 2), (3, 4)];
+    let graph = build_graph(&edges);
+    let path = shortest_path(&graph, 1, 4).expect("shortest");
+    assert_eq!(path, None);
+}
+
+#[test]
+fn test_bfs_deterministic_with_same_insert_order() {
+    let edges = vec![(1, 3), (1, 2), (2, 4), (2, 5)];
+    let graph = build_graph(&edges);
+    let visited = bfs_neighbors(&graph, 1, 10).expect("bfs");
+    assert_eq!(visited, vec![1, 2, 3, 4, 5]);
+}
+
+#[test]
+fn test_bfs_deterministic_with_shuffled_insert_order() {
+    let mut edges = vec![(2, 4), (1, 3), (1, 2), (2, 5)];
+    let graph = build_graph(&edges);
+    edges.reverse();
+    let graph_b = build_graph(&edges);
+    let visited_a = bfs_neighbors(&graph, 1, 10).expect("bfs A");
+    let visited_b = bfs_neighbors(&graph_b, 1, 10).expect("bfs B");
+    assert_eq!(visited_a, visited_b);
+}
+
+#[test]
+fn test_bfs_respects_max_depth() {
+    let edges = vec![(1, 2), (2, 3), (3, 4)];
+    let graph = build_graph(&edges);
+    let visited = bfs_neighbors(&graph, 1, 1).expect("bfs");
+    assert_eq!(visited, vec![1, 2]);
+}
+
+#[test]
+fn test_shortest_path_prefers_lexicographic_neighbors() {
+    let edges = vec![(1, 2), (1, 3), (2, 4), (3, 4)];
+    let graph = build_graph(&edges);
+    let path = shortest_path(&graph, 1, 4).expect("shortest");
+    assert_eq!(path, Some(vec![1, 2, 4]));
+}
+
+#[test]
+fn test_bfs_neighbors_filtered_restricts_traversal_to_allowed_edge_types() {
+    let edges = vec![
+        (1, 2, "CALL"),
+        (2, 3, "CALL"),
+        (1, 4, "IMPORTS"),
+        (4, 5, "IMPORTS"),
+    ];
+    let graph = build_typed_graph(&edges);
+    let visited =
+        bfs_neighbors_filtered(&graph, 1, 10, &["CALL"], BackendDirection::Outgoing).expect("bfs");
+    assert_eq!(visited, vec![1, 2, 3]);
+}
+
+#[test]
+fn test_bfs_neighbors_filtered_empty_allowed_types_returns_empty() {
+    let edges = vec![(1, 2, "CALL"), (2, 3, "CALL")];
+    let graph = build_typed_graph(&edges);
+    let visited =
+        bfs_neighbors_filtered(&graph, 1, 10, &[], BackendDirection::Outgoing).expect("bfs");
+    assert!(visited.is_empty());
+}
+
+#[test]
+fn test_bfs_neighbors_filtered_multiple_kinds_unions_neighbors() {
+    let edges = vec![
+        (1, 2, "CALL"),
+        (1, 3, "IMPORTS"),
+        (1, 4, "TESTS"),
+        (2, 5, "CALL"),
+    ];
+    let graph = build_typed_graph(&edges);
+    let visited = bfs_neighbors_filtered(
+        &graph,
+        1,
+        10,
+        &["CALL", "IMPORTS"],
+        BackendDirection::Outgoing,
+    )
+    .expect("bfs");
+    assert!(visited.contains(&2));
+    assert!(visited.contains(&3));
+    assert!(visited.contains(&5));
+    assert!(!visited.contains(&4));
+}
+
+#[test]
+fn test_bfs_neighbors_filtered_incoming_direction() {
+    let edges = vec![(1, 5, "CALL"), (2, 5, "CALL"), (3, 5, "IMPORTS")];
+    let graph = build_typed_graph(&edges);
+    let visited =
+        bfs_neighbors_filtered(&graph, 5, 10, &["CALL"], BackendDirection::Incoming).expect("bfs");
+    assert!(visited.contains(&5));
+    assert!(visited.contains(&1));
+    assert!(visited.contains(&2));
+    assert!(!visited.contains(&3));
+}
+
+#[test]
+fn test_shortest_path_filtered_uses_only_allowed_kinds() {
+    let edges = vec![
+        (1, 2, "CALL"),
+        (2, 3, "CALL"),
+        (1, 4, "IMPORTS"),
+        (4, 3, "IMPORTS"),
+    ];
+    let graph = build_typed_graph(&edges);
+    let path = shortest_path_filtered(&graph, 1, 3, &["CALL"]).expect("shortest");
+    assert_eq!(path, Some(vec![1, 2, 3]));
+    let path_imports = shortest_path_filtered(&graph, 1, 3, &["IMPORTS"]).expect("shortest");
+    assert_eq!(path_imports, Some(vec![1, 4, 3]));
+}
+
+#[test]
+fn test_shortest_path_filtered_returns_none_when_kind_excludes_only_path() {
+    let edges = vec![(1, 2, "IMPORTS"), (2, 3, "IMPORTS")];
+    let graph = build_typed_graph(&edges);
+    let path = shortest_path_filtered(&graph, 1, 3, &["CALL"]).expect("shortest");
+    assert_eq!(path, None);
+}
+
+#[test]
+fn test_shortest_path_filtered_empty_allowed_types_returns_none() {
+    let edges = vec![(1, 2, "CALL"), (2, 3, "CALL")];
+    let graph = build_typed_graph(&edges);
+    let path = shortest_path_filtered(&graph, 1, 3, &[]).expect("shortest");
+    assert_eq!(path, None);
+}
+
+#[test]
+fn test_shortest_path_filtered_same_node_returns_singleton() {
+    let edges = vec![(1, 2, "CALL")];
+    let graph = build_typed_graph(&edges);
+    let path = shortest_path_filtered(&graph, 1, 1, &["CALL"]).expect("shortest");
+    assert_eq!(path, Some(vec![1]));
+}

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-py/CHANGELOG.md

@@ -3,6 +3,31 @@
 This file tracks releases of the `sqlitegraph` package on PyPI. The Rust
 crate of the same name has its own changelog at the repository root.
 
+## [0.2.0] - 2026-05-15
+
+### Added
+- **`bfs(start, depth, edge_types=None, direction=None)`** — `bfs` now accepts
+  an optional `edge_types` list and `direction` (`"outgoing"` or
+  `"incoming"`). When `edge_types` is provided, traversal only follows edges
+  whose type is in the list, dispatching to the new
+  `GraphBackend::bfs_filtered`. With `edge_types=None`, behavior is unchanged
+  (outgoing traversal, all edge types).
+- **`shortest_path(start, end, edge_types=None)`** — Optional `edge_types`
+  list restricts which edge types the path can traverse, dispatching to
+  `GraphBackend::shortest_path_filtered`. Empty list returns `None`.
+- **`k_hop(start, depth, direction=None, edge_types=None)`** — The existing
+  `k_hop` now exposes `edge_types`, dispatching to
+  `GraphBackend::k_hop_filtered` when provided. Empty list returns an empty
+  result.
+- **11 new pytest tests** in `tests/test_filtered_traversal.py` covering each
+  new kwarg plus backwards-compatibility checks for the old kwargless calls.
+
+### Notes
+- Built against `sqlitegraph` (Rust) **v2.3.0**, which adds the underlying
+  `bfs_filtered` / `shortest_path_filtered` trait methods.
+- All existing tests continue to pass without modification — the new kwargs
+  are strictly additive.
+
 ## [0.1.1] - 2026-05-15
 
 ### Fixed

{sqlitegraph-0.1.1 → sqlitegraph-0.2.0}/sqlitegraph-py/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph-py"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2021"
 description = "Python bindings for sqlitegraph via PyO3"
 license = "GPL-3.0-only"