sqlitegraph 0.1.0__tar.gz → 0.1.1__tar.gz

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

@@ -1387,7 +1387,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "sqlitegraph"
-version = "2.2.4"
+version = "2.2.5"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1418,7 +1418,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-cli"
-version = "2.1.4"
+version = "2.1.5"
 dependencies = [
  "anyhow",
  "clap",
@@ -1428,7 +1428,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-py"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "ndarray 0.16.1",
  "numpy",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlitegraph
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
@@ -54,6 +54,23 @@ g.add_edge(alice, order, "placed")
 print(g.neighbors(alice))
 ```
 
-A polished README with vector-search and code-metadata examples will land
-alongside the first PyPI release.
+## Examples
+
+The [`examples/`](./examples/) directory contains runnable scripts:
+
+| Example | What it shows |
+|---------|---------------|
+| [`01_basic_crud.py`](./examples/01_basic_crud.py) | Nodes, edges, update, delete, query by kind/pattern, degrees |
+| [`02_graph_algorithms.py`](./examples/02_graph_algorithms.py) | BFS, k-hop, shortest path, PageRank, Louvain communities, connected components |
+| [`03_vector_search.py`](./examples/03_vector_search.py) | HNSW index creation, insert, search, bulk insert, index listing |
+| [`04_social_network.py`](./examples/04_social_network.py) | Realistic network: influencers (PageRank), communities, connection paths, mutual follows |
+| [`05_file_backed.py`](./examples/05_file_backed.py) | Persistent `Graph.open(path)`, checkpoint, reopen, cleanup |
+
+Run any example from the repo root:
+
+```bash
+cd sqlitegraph-py
+source .venv/bin/activate
+python examples/01_basic_crud.py
+```
 

sqlitegraph-0.1.1/README.md

@@ -0,0 +1,44 @@
+# sqlitegraph
+
+Python bindings to the [`sqlitegraph`](https://crates.io/crates/sqlitegraph)
+embedded graph database. Storage, graph algorithms, and HNSW vector search
+run in a reviewed Rust core; this package is the Pythonic surface.
+
+> Alpha — API subject to change before 1.0.
+
+## Install
+
+    pip install sqlitegraph
+
+## Quick start
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+alice = g.add_node(kind="User", name="Alice", data={"age": 30})
+order = g.add_node(kind="Order", name="Order-123")
+g.add_edge(alice, order, "placed")
+
+print(g.neighbors(alice))
+```
+
+## Examples
+
+The [`examples/`](./examples/) directory contains runnable scripts:
+
+| Example | What it shows |
+|---------|---------------|
+| [`01_basic_crud.py`](./examples/01_basic_crud.py) | Nodes, edges, update, delete, query by kind/pattern, degrees |
+| [`02_graph_algorithms.py`](./examples/02_graph_algorithms.py) | BFS, k-hop, shortest path, PageRank, Louvain communities, connected components |
+| [`03_vector_search.py`](./examples/03_vector_search.py) | HNSW index creation, insert, search, bulk insert, index listing |
+| [`04_social_network.py`](./examples/04_social_network.py) | Realistic network: influencers (PageRank), communities, connection paths, mutual follows |
+| [`05_file_backed.py`](./examples/05_file_backed.py) | Persistent `Graph.open(path)`, checkpoint, reopen, cleanup |
+
+Run any example from the repo root:
+
+```bash
+cd sqlitegraph-py
+source .venv/bin/activate
+python examples/01_basic_crud.py
+```

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

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlitegraph"
-version = "0.1.0"
+version = "0.1.1"
 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.0 → sqlitegraph-0.1.1}/sqlitegraph-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph"
-version = "2.2.4"
+version = "2.2.5"
 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.0 → sqlitegraph-0.1.1}/sqlitegraph-core/src/hnsw/index_api.rs

@@ -526,10 +526,11 @@ impl crate::SqliteGraph {
                 .map_err(|e| crate::SqliteGraphError::invalid_input(format!("Failed to get index_id: {}", e)))?
                 .ok_or_else(|| crate::SqliteGraphError::invalid_input("Failed to get index_id after saving metadata".to_string()))?;
 
-            // Get database path to open a new connection for storage
+            // Get database path to open a new connection for storage.
+            // `database_list` columns: 0=seq, 1=name ("main"), 2=file (actual path).
             let db_path = conn_ref.pragma_query_value(None, "database_list", |row| {
-                let name: String = row.get(1)?;
-                Ok(name)
+                let file: String = row.get(2)?;
+                Ok(file)
             }).map_err(|e| crate::SqliteGraphError::invalid_input(format!("Failed to get database path: {}", e)))?;
 
             let conn_for_storage = rusqlite::Connection::open(&db_path)

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

@@ -3,6 +3,16 @@
 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.1.1] - 2026-05-15
+
+### Fixed
+- **`create_hnsw_index` now calls `hnsw_index_persistent`** — Previously the
+  Python binding called the non-persistent `hnsw_index()`, so vector indexes
+  created from Python were lost when the `Graph` object was dropped. Now it
+  calls `hnsw_index_persistent()`, matching the expected durability contract.
+  Requires `sqlitegraph` (Rust) **>= 2.2.5** (the release that fixes the
+  underlying `database_list` column read).
+
 ## [0.1.0] — unreleased
 
 ### Added

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

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

sqlitegraph-0.1.1/sqlitegraph-py/README.md

@@ -0,0 +1,44 @@
+# sqlitegraph
+
+Python bindings to the [`sqlitegraph`](https://crates.io/crates/sqlitegraph)
+embedded graph database. Storage, graph algorithms, and HNSW vector search
+run in a reviewed Rust core; this package is the Pythonic surface.
+
+> Alpha — API subject to change before 1.0.
+
+## Install
+
+    pip install sqlitegraph
+
+## Quick start
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+alice = g.add_node(kind="User", name="Alice", data={"age": 30})
+order = g.add_node(kind="Order", name="Order-123")
+g.add_edge(alice, order, "placed")
+
+print(g.neighbors(alice))
+```
+
+## Examples
+
+The [`examples/`](./examples/) directory contains runnable scripts:
+
+| Example | What it shows |
+|---------|---------------|
+| [`01_basic_crud.py`](./examples/01_basic_crud.py) | Nodes, edges, update, delete, query by kind/pattern, degrees |
+| [`02_graph_algorithms.py`](./examples/02_graph_algorithms.py) | BFS, k-hop, shortest path, PageRank, Louvain communities, connected components |
+| [`03_vector_search.py`](./examples/03_vector_search.py) | HNSW index creation, insert, search, bulk insert, index listing |
+| [`04_social_network.py`](./examples/04_social_network.py) | Realistic network: influencers (PageRank), communities, connection paths, mutual follows |
+| [`05_file_backed.py`](./examples/05_file_backed.py) | Persistent `Graph.open(path)`, checkpoint, reopen, cleanup |
+
+Run any example from the repo root:
+
+```bash
+cd sqlitegraph-py
+source .venv/bin/activate
+python examples/01_basic_crud.py
+```

sqlitegraph-0.1.1/sqlitegraph-py/examples/01_basic_crud.py

@@ -0,0 +1,71 @@
+"""Basic CRUD operations with sqlitegraph.
+
+Demonstrates: open, add_node, get_node, update_node, delete_node,
+add_edge, get_edge, delete_edge, neighbors, node_degree.
+"""
+
+from sqlitegraph import Graph
+
+# Open an in-memory graph (fast, no persistence)
+g = Graph.open_in_memory()
+print("=== Basic CRUD ===\n")
+
+# -- Nodes --
+
+alice = g.add_node(kind="User", name="Alice", data={"age": 30, "city": "Berlin"})
+bob = g.add_node(kind="User", name="Bob", data={"age": 25, "city": "Paris"})
+project = g.add_node(kind="Project", name="GraphDB", data={"status": "active"})
+company = g.add_node(kind="Company", name="TechCorp", data={"founded": 2020})
+
+print(f"Created nodes: Alice={alice}, Bob={bob}, Project={project}, Company={company}")
+
+# Read a node back
+node = g.get_node(alice)
+print(f"\nAlice's node: {node}")
+
+# Update a node
+g.update_node(bob, kind="User", name="Bob", data={"age": 26, "city": "Paris", "promoted": True})
+updated = g.get_node(bob)
+print(f"Updated Bob: {updated}")
+
+# -- Edges --
+
+# Alice works_on Project
+e1 = g.add_edge(alice, project, "works_on", data={"role": "developer"})
+# Project belongs_to Company
+e2 = g.add_edge(project, company, "belongs_to", data={"ownership": 0.75})
+# Alice employed_by Company
+e3 = g.add_edge(alice, company, "employed_by", data={"department": "engineering"})
+
+print(f"\nCreated edges: works_on={e1}, belongs_to={e2}, employed_by={e3}")
+
+# Read an edge back
+edge = g.get_edge(e1)
+print(f"Edge {e1}: {edge['edge_type']} from {edge['from_id']} to {edge['to_id']}")
+
+# -- Neighbors & degrees --
+
+print(f"\nAlice's outgoing neighbors: {g.neighbors(alice, direction='outgoing')}")
+print(f"Alice's incoming neighbors: {g.neighbors(alice, direction='incoming')}")
+print(f"Alice's all neighbors: {g.neighbors(alice)}")
+
+in_deg, out_deg = g.node_degree(alice)
+print(f"\nAlice's degree: in={in_deg}, out={out_deg}")
+
+# -- Query by kind / pattern --
+
+users = g.nodes_by_kind("User")
+print(f"\nAll users: {users}")
+
+matches = g.nodes_by_name_pattern("Al*")
+print(f"Names matching 'Al*': {matches}")
+
+# -- Delete --
+
+# Delete an edge
+g.delete_edge(e3)
+print(f"\nDeleted edge {e3}. Alice's neighbors now: {g.neighbors(alice)}")
+
+# Delete a node (also deletes attached edges)
+g.delete_node(bob)
+print(f"Deleted Bob. Remaining node IDs: {g.node_ids()}")

sqlitegraph-0.1.1/sqlitegraph-py/examples/02_graph_algorithms.py

@@ -0,0 +1,99 @@
+"""Graph algorithms with sqlitegraph.
+
+Demonstrates: bfs, k_hop, shortest_path, pagerank,
+louvain_communities, connected_components.
+"""
+
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+print("=== Graph Algorithms ===\n")
+
+# Build a sample graph: two disjoint triangles plus a bridge
+# Triangle 1: a-b-c-a
+# Triangle 2: d-e-f-d
+# Bridge: c-d
+
+a = g.add_node(kind="Node", name="a")
+b = g.add_node(kind="Node", name="b")
+c = g.add_node(kind="Node", name="c")
+d = g.add_node(kind="Node", name="d")
+e = g.add_node(kind="Node", name="e")
+f = g.add_node(kind="Node", name="f")
+
+for u, v in [(a, b), (b, c), (c, a)]:
+    g.add_edge(u, v, "link")
+for u, v in [(d, e), (e, f), (f, d)]:
+    g.add_edge(u, v, "link")
+g.add_edge(c, d, "bridge")
+
+print("Graph: two triangles linked by a bridge (c-d)")
+
+# -- BFS --
+
+reached = g.bfs(a, depth=2)
+print(f"\nBFS from a (depth=2): {sorted(reached)}")
+
+# -- k-hop --
+
+khop = g.k_hop(a, depth=2)
+print(f"k-hop from a (depth=2): {sorted(khop)}")
+
+# -- Shortest path --
+
+path = g.shortest_path(a, f)
+print(f"\nShortest path a -> f: {path}")
+
+path = g.shortest_path(a, e)
+print(f"Shortest path a -> e: {path}")
+
+# No connection possible if we delete the bridge
+g.delete_edge(g.get_edge(7)["id"] if False else 7)  # edge IDs are 1-based
+# Actually let's just show unreachable
+isolated = g.add_node(kind="Node", name="isolated")
+no_path = g.shortest_path(a, isolated)
+print(f"Shortest path a -> isolated (no edge): {no_path}")
+
+# -- PageRank --
+
+# Build a directed cycle for PageRank: a->b->c->a
+h = Graph.open_in_memory()
+na = h.add_node(kind="Page", name="A")
+nb = h.add_node(kind="Page", name="B")
+nc = h.add_node(kind="Page", name="C")
+h.add_edge(na, nb, "links")
+h.add_edge(nb, nc, "links")
+h.add_edge(nc, na, "links")
+
+scores = h.pagerank(damping=0.85, iterations=20)
+print("\n--- PageRank (cycle of 3) ---")
+for nid, score in scores:
+    node = h.get_node(nid)
+    print(f"  {node['name']}: {score:.6f}")
+
+# -- Louvain Communities --
+
+communities = g.louvain_communities(max_iterations=10)
+print("\n--- Louvain Communities ---")
+print(f"Found {len(communities)} communities:")
+for i, comm in enumerate(communities):
+    names = [g.get_node(nid)["name"] for nid in comm]
+    print(f"  Community {i}: {names}")
+
+# -- Connected Components --
+
+# Add an isolated pair to the first graph
+g2 = Graph.open_in_memory()
+x = g2.add_node(kind="Node", name="x")
+y = g2.add_node(kind="Node", name="y")
+z = g2.add_node(kind="Node", name="z")
+g2.add_edge(x, y, "link")  # component 1
+# z is alone — but singletons aren't returned by connected_components
+# unless they have self-loops, so this gives 1 component
+
+components = g2.connected_components()
+print("\n--- Connected Components ---")
+print(f"Found {len(components)} component(s)")
+for i, comp in enumerate(components):
+    names = [g2.get_node(nid)["name"] for nid in comp]
+    print(f"  Component {i}: {names}")

sqlitegraph-0.1.1/sqlitegraph-py/examples/03_vector_search.py

@@ -0,0 +1,66 @@
+"""HNSW vector search with sqlitegraph.
+
+Demonstrates: create_hnsw_index, insert_vector, search,
+get_vector, vector_count, list_hnsw_indexes, get_hnsw_index.
+"""
+
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+print("=== HNSW Vector Search ===\n")
+
+# Create an HNSW index for 3-dimensional vectors using cosine similarity
+idx = g.create_hnsw_index("embeddings", dimension=3, metric="cosine")
+print(f"Created index: {idx.name()}")
+
+# Insert some vectors
+# These are simplified "document embeddings" — in practice you'd use
+# an embedding model (e.g. sentence-transformers, OpenAI, etc.)
+
+# "machine learning" direction
+v_ml = idx.insert_vector([1.0, 0.8, 0.1])
+# "deep learning" direction (similar to ML)
+v_dl = idx.insert_vector([0.9, 0.85, 0.05])
+# "baking" direction (unrelated)
+v_bake = idx.insert_vector([0.1, 0.2, 1.0])
+# "cooking" direction (similar to baking)
+v_cook = idx.insert_vector([0.05, 0.15, 0.95])
+
+print(f"Inserted vectors: ML={v_ml}, DL={v_dl}, Bake={v_bake}, Cook={v_cook}")
+print(f"Total vectors in index: {idx.vector_count()}")
+
+# Search for vectors similar to "machine learning"
+query = [1.0, 0.9, 0.0]  # close to ML/DL
+top2 = idx.search(query, k=2)
+print("\nSearch for [1.0, 0.9, 0.0] (top 2):")
+for vid, distance in top2:
+    print(f"  vector_id={vid}, distance={distance:.4f}")
+
+# Search for vectors similar to "cooking/baking"
+query2 = [0.0, 0.0, 1.0]  # close to Bake/Cook
+top2 = idx.search(query2, k=2)
+print("\nSearch for [0.0, 0.0, 1.0] (top 2):")
+for vid, distance in top2:
+    print(f"  vector_id={vid}, distance={distance:.4f}")
+
+# Retrieve a specific vector by ID
+vec = idx.get_vector(v_ml)
+print(f"\nVector {v_ml}: {vec}")
+
+# List all indexes
+print(f"\nAll HNSW indexes: {g.list_hnsw_indexes()}")
+
+# Re-open the index by name
+idx2 = g.get_hnsw_index("embeddings")
+print(f"Re-opened index: {idx2.name()}, vectors: {idx2.vector_count()}")
+
+# Bulk insert example
+print("\n--- Bulk insert ---")
+vectors = [
+    ([0.5, 0.5, 0.0], None),
+    ([0.6, 0.4, 0.0], {"tag": "ml"}),
+    ([0.0, 0.0, 0.8], {"tag": "cooking"}),
+]
+bulk_ids = idx.bulk_insert_vectors(vectors)
+print(f"Bulk inserted {len(bulk_ids)} vectors: {bulk_ids}")
+print(f"Total vectors now: {idx.vector_count()}")

sqlitegraph-0.1.1/sqlitegraph-py/examples/04_social_network.py

@@ -0,0 +1,99 @@
+"""Social network analysis with sqlitegraph.
+
+A realistic example: model a small social network, find influencers
+via PageRank, detect communities via Louvain, and find connection paths.
+"""
+
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+print("=== Social Network Analysis ===\n")
+
+# Create people
+people = {
+    "alice": g.add_node(kind="Person", name="Alice", data={"role": "engineer"}),
+    "bob": g.add_node(kind="Person", name="Bob", data={"role": "designer"}),
+    "carol": g.add_node(kind="Person", name="Carol", data={"role": "manager"}),
+    "dave": g.add_node(kind="Person", name="Dave", data={"role": "engineer"}),
+    "eve": g.add_node(kind="Person", name="Eve", data={"role": "analyst"}),
+    "frank": g.add_node(kind="Person", name="Frank", data={"role": "intern"}),
+    "grace": g.add_node(kind="Person", name="Grace", data={"role": "cto"}),
+}
+
+# Create follows edges (directed: A follows B)
+follows = [
+    ("alice", "bob"),  # alice follows bob
+    ("alice", "carol"),  # alice follows carol
+    ("bob", "carol"),  # bob follows carol
+    ("carol", "grace"),  # carol follows grace (the CTO)
+    ("dave", "alice"),  # dave follows alice
+    ("dave", "bob"),  # dave follows bob
+    ("eve", "carol"),  # eve follows carol
+    ("frank", "alice"),  # frank follows alice
+    ("frank", "dave"),  # frank follows dave
+    ("grace", "carol"),  # grace follows carol (mutual)
+]
+
+for follower, followee in follows:
+    g.add_edge(people[follower], people[followee], "follows")
+
+print("Social network created:")
+print(f"  People: {len(people)}")
+print(f"  Follows edges: {len(follows)}")
+
+# -- Find influencers with PageRank --
+
+scores = g.pagerank(damping=0.85, iterations=50)
+print("\n--- Influencers (PageRank) ---")
+# Sort by score descending
+ranked = sorted(scores, key=lambda x: x[1], reverse=True)
+for nid, score in ranked:
+    name = g.get_node(nid)["name"]
+    in_deg, out_deg = g.node_degree(nid)
+    print(f"  {name:6s}: score={score:.4f}  (in={in_deg}, out={out_deg})")
+
+# -- Find communities --
+
+communities = g.louvain_communities(max_iterations=10)
+print("\n--- Communities (Louvain) ---")
+print(f"Found {len(communities)} communities:")
+for i, comm in enumerate(communities):
+    names = [g.get_node(nid)["name"] for nid in comm]
+    print(f"  Community {i}: {', '.join(names)}")
+
+# -- Find connection paths --
+
+print("\n--- Connection Paths ---")
+path = g.shortest_path(people["frank"], people["grace"])
+if path:
+    names = [g.get_node(nid)["name"] for nid in path]
+    print(f"  Frank -> Grace: {' -> '.join(names)}")
+else:
+    print("  Frank -> Grace: no path")
+
+path = g.shortest_path(people["eve"], people["dave"])
+if path:
+    names = [g.get_node(nid)["name"] for nid in path]
+    print(f"  Eve -> Dave: {' -> '.join(names)}")
+else:
+    print("  Eve -> Dave: no path")
+
+# -- Mutual follows --
+
+print("\n--- Mutual Follows ---")
+for name_a, nid_a in people.items():
+    for name_b, nid_b in people.items():
+        if name_a >= name_b:
+            continue
+        a_follows_b = nid_b in g.neighbors(nid_a, direction="outgoing")
+        b_follows_a = nid_a in g.neighbors(nid_b, direction="outgoing")
+        if a_follows_b and b_follows_a:
+            print(f"  {name_a.title()} <-> {name_b.title()}")
+
+# -- Who follows the CTO? --
+
+grace_id = people["grace"]
+followers_of_cto = g.neighbors(grace_id, direction="incoming")
+print("\n--- Followers of Grace (CTO) ---")
+for nid in followers_of_cto:
+    print(f"  {g.get_node(nid)['name']}")

sqlitegraph-0.1.1/sqlitegraph-py/examples/05_file_backed.py

@@ -0,0 +1,56 @@
+"""Persistent file-backed graph with sqlitegraph.
+
+Demonstrates: Graph.open(path), checkpoint, reopen, and data durability.
+"""
+
+import os
+import tempfile
+
+from sqlitegraph import Graph
+
+# Use a temporary file for the demo
+db_path = os.path.join(tempfile.gettempdir(), "sqlitegraph_demo.db")
+print("=== File-Backed Graph ===\n")
+print(f"Database path: {db_path}\n")
+
+# Clean up any previous demo file
+if os.path.exists(db_path):
+    os.remove(db_path)
+
+# -- Create and populate --
+
+g = Graph.open(db_path)
+print("Created file-backed graph.")
+
+alice = g.add_node(kind="User", name="Alice", data={"age": 30})
+bob = g.add_node(kind="User", name="Bob", data={"age": 25})
+project = g.add_node(kind="Project", name="GraphDB")
+
+g.add_edge(alice, project, "works_on")
+g.add_edge(bob, project, "works_on")
+
+print(f"Added {len(g.node_ids())} nodes and edges.")
+
+# Checkpoint to ensure data is flushed
+g.checkpoint()
+print("Checkpoint complete.\n")
+
+# -- Re-open and verify --
+
+g2 = Graph.open(db_path)
+print("Re-opened graph from disk.")
+
+print(f"Node count: {len(g2.node_ids())}")
+print(f"Nodes by kind 'User': {g2.nodes_by_kind('User')}")
+
+# Retrieve Alice
+users = g2.nodes_by_kind("User")
+for uid in users:
+    node = g2.get_node(uid)
+    print(f"  {node['name']}: {node['data']}")
+
+# -- Clean up --
+
+if os.path.exists(db_path):
+    os.remove(db_path)
+    print(f"\nCleaned up {db_path}")

{sqlitegraph-0.1.0 → sqlitegraph-0.1.1}/sqlitegraph-py/src/lib.rs

@@ -379,7 +379,9 @@ impl Graph {
         let index_name = {
             let this = slf.borrow();
             let graph = this.backend.graph();
-            let mut indexes = graph.hnsw_index(&name, config).map_err(into_pyerr)?;
+            let mut indexes = graph
+                .hnsw_index_persistent(&name, config)
+                .map_err(into_pyerr)?;
             let index = indexes
                 .get_mut(&name)
                 .ok_or_else(|| BackendError::new_err("Index not found after creation"))?;

sqlitegraph-0.1.0/README.md

@@ -1,27 +0,0 @@
-# sqlitegraph
-
-Python bindings to the [`sqlitegraph`](https://crates.io/crates/sqlitegraph)
-embedded graph database. Storage, graph algorithms, and HNSW vector search
-run in a reviewed Rust core; this package is the Pythonic surface.
-
-> Alpha — API subject to change before 1.0.
-
-## Install
-
-    pip install sqlitegraph
-
-## Quick start
-
-```python
-from sqlitegraph import Graph
-
-g = Graph.open_in_memory()
-alice = g.add_node(kind="User", name="Alice", data={"age": 30})
-order = g.add_node(kind="Order", name="Order-123")
-g.add_edge(alice, order, "placed")
-
-print(g.neighbors(alice))
-```
-
-A polished README with vector-search and code-metadata examples will land
-alongside the first PyPI release.