sqlitegraph 0.2.0__tar.gz → 0.3.0__tar.gz

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph"
-version = "2.3.0"
+version = "2.4.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.2.0 → sqlitegraph-0.3.0}/sqlitegraph-core/src/backend/sqlite/impl_.rs

@@ -296,6 +296,62 @@ impl crate::backend::GraphBackend for SqliteGraphBackend {
         Ok(id)
     }
 
+    fn insert_nodes_bulk(&self, nodes: &[NodeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let entities: Vec<GraphEntity> = nodes
+            .iter()
+            .map(|node| GraphEntity {
+                id: 0,
+                kind: node.kind.clone(),
+                name: node.name.clone(),
+                file_path: node.file_path.clone(),
+                data: node.data.clone(),
+            })
+            .collect();
+        let ids = self.graph.insert_entities_bulk(&entities)?;
+
+        // Emit per-row events after the commit, matching single-insert
+        // observer semantics.
+        let pub_guard = self.publisher.read();
+        if let Some(ref publisher) = *pub_guard {
+            for id in &ids {
+                publisher.emit(PubSubEvent::NodeChanged {
+                    node_id: *id,
+                    snapshot_id: 0,
+                });
+            }
+        }
+
+        Ok(ids)
+    }
+
+    fn insert_edges_bulk(&self, edges: &[EdgeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let graph_edges: Vec<GraphEdge> = edges
+            .iter()
+            .map(|edge| GraphEdge {
+                id: 0,
+                from_id: edge.from,
+                to_id: edge.to,
+                edge_type: edge.edge_type.clone(),
+                data: edge.data.clone(),
+            })
+            .collect();
+        let ids = self.graph.insert_edges_bulk(&graph_edges)?;
+
+        let pub_guard = self.publisher.read();
+        if let Some(ref publisher) = *pub_guard {
+            for (id, edge) in ids.iter().zip(edges.iter()) {
+                publisher.emit(PubSubEvent::EdgeChanged {
+                    from_node: edge.from,
+                    to_node: edge.to,
+                    edge_id: *id,
+                    snapshot_id: 0,
+                });
+            }
+        }
+
+        Ok(ids)
+    }
+
     fn delete_entity(&self, id: i64) -> Result<(), SqliteGraphError> {
         self.graph.delete_entity(id)
     }

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

@@ -117,6 +117,35 @@ pub trait GraphBackend {
     fn insert_node(&self, node: NodeSpec) -> Result<i64, SqliteGraphError>;
     fn insert_edge(&self, edge: EdgeSpec) -> Result<i64, SqliteGraphError>;
 
+    /// Insert many nodes atomically.
+    ///
+    /// Default implementation loops single-insert for each item; backends
+    /// override with a single-transaction path. Returns the new node IDs in
+    /// the same order as `nodes`. All-or-nothing: if any insert fails the
+    /// caller should assume nothing was committed.
+    fn insert_nodes_bulk(&self, nodes: &[NodeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let mut ids = Vec::with_capacity(nodes.len());
+        for n in nodes {
+            ids.push(self.insert_node(n.clone())?);
+        }
+        Ok(ids)
+    }
+
+    /// Insert many edges atomically.
+    ///
+    /// Default implementation loops single-insert for each item; backends
+    /// override with a single-transaction path. Returns the new edge IDs in
+    /// the same order as `edges`. All-or-nothing semantics on the bulk path;
+    /// the default fallback inherits whatever atomicity the single
+    /// `insert_edge` provides.
+    fn insert_edges_bulk(&self, edges: &[EdgeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let mut ids = Vec::with_capacity(edges.len());
+        for e in edges {
+            ids.push(self.insert_edge(e.clone())?);
+        }
+        Ok(ids)
+    }
+
     /// Update an existing node in place without allocating a new node ID
     ///
     /// This modifies the data associated with an existing node while preserving
@@ -565,6 +594,14 @@ where
         (*self).entity_ids()
     }
 
+    fn insert_nodes_bulk(&self, nodes: &[NodeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        (*self).insert_nodes_bulk(nodes)
+    }
+
+    fn insert_edges_bulk(&self, edges: &[EdgeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        (*self).insert_edges_bulk(edges)
+    }
+
     fn neighbors(
         &self,
         snapshot_id: SnapshotId,

sqlitegraph-0.3.0/sqlitegraph-core/src/graph/edge_ops.rs

@@ -0,0 +1,118 @@
+//! Edge CRUD operations for SqliteGraph.
+
+use rusqlite::params;
+
+use crate::errors::SqliteGraphError;
+
+use super::{
+    SqliteGraph,
+    types::{GraphEdge, row_to_edge, validate_edge},
+};
+
+impl SqliteGraph {
+    pub fn insert_edge(&self, edge: &GraphEdge) -> Result<i64, SqliteGraphError> {
+        validate_edge(edge)?;
+        if !self.entity_exists(edge.from_id)? || !self.entity_exists(edge.to_id)? {
+            return Err(SqliteGraphError::invalid_input(
+                "edge endpoints must reference existing entities",
+            ));
+        }
+        let data = serde_json::to_string(&edge.data)
+            .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
+        self.connection()
+            .execute(
+                "INSERT INTO graph_edges(from_id, to_id, edge_type, data) VALUES(?1, ?2, ?3, ?4)",
+                params![edge.from_id, edge.to_id, edge.edge_type.as_str(), data],
+            )
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+        self.invalidate_caches();
+        Ok(self.connection().last_insert_rowid())
+    }
+
+    /// Insert many edges atomically inside a single transaction.
+    ///
+    /// Returns the rowids of the inserted edges in the same order as the
+    /// input. Empty input returns an empty vector without opening a
+    /// transaction. On any error, the transaction is rolled back and the
+    /// database is left untouched.
+    pub fn insert_edges_bulk(&self, edges: &[GraphEdge]) -> Result<Vec<i64>, SqliteGraphError> {
+        if edges.is_empty() {
+            return Ok(Vec::new());
+        }
+        for edge in edges {
+            validate_edge(edge)?;
+            if !self.entity_exists(edge.from_id)? || !self.entity_exists(edge.to_id)? {
+                return Err(SqliteGraphError::invalid_input(
+                    "edge endpoints must reference existing entities",
+                ));
+            }
+        }
+        let conn = self.connection();
+        conn.underlying()
+            .execute_batch("BEGIN")
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+
+        let mut ids = Vec::with_capacity(edges.len());
+        let insert_result: Result<(), SqliteGraphError> = (|| {
+            let mut stmt = conn
+                .prepare_cached(
+                    "INSERT INTO graph_edges(from_id, to_id, edge_type, data) VALUES(?1, ?2, ?3, ?4)",
+                )
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+            for edge in edges {
+                let data = serde_json::to_string(&edge.data)
+                    .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
+                stmt.execute(params![
+                    edge.from_id,
+                    edge.to_id,
+                    edge.edge_type.as_str(),
+                    data,
+                ])
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                ids.push(conn.last_insert_rowid());
+            }
+            Ok(())
+        })();
+
+        match insert_result {
+            Ok(()) => {
+                conn.underlying()
+                    .execute_batch("COMMIT")
+                    .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                self.invalidate_caches();
+                Ok(ids)
+            }
+            Err(err) => {
+                let _ = conn.underlying().execute_batch("ROLLBACK");
+                Err(err)
+            }
+        }
+    }
+
+    pub fn get_edge(&self, id: i64) -> Result<GraphEdge, SqliteGraphError> {
+        self.connection()
+            .query_row(
+                "SELECT id, from_id, to_id, edge_type, data FROM graph_edges WHERE id=?1",
+                params![id],
+                row_to_edge,
+            )
+            .map_err(|err| match err {
+                rusqlite::Error::QueryReturnedNoRows => {
+                    SqliteGraphError::not_found(format!("edge {id}"))
+                }
+                other => SqliteGraphError::query(other.to_string()),
+            })
+    }
+
+    pub fn delete_edge(&self, id: i64) -> Result<(), SqliteGraphError> {
+        let affected = self
+            .connection()
+            .execute("DELETE FROM graph_edges WHERE id=?1", params![id])
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+        if affected == 0 {
+            return Err(SqliteGraphError::not_found(format!("edge {id}")));
+        }
+        self.invalidate_caches();
+        Ok(())
+    }
+}

{sqlitegraph-0.2.0 → sqlitegraph-0.3.0}/sqlitegraph-core/src/graph/entity_ops.rs

@@ -28,6 +28,63 @@ impl SqliteGraph {
         Ok(self.connection().last_insert_rowid())
     }
 
+    /// Insert many entities atomically inside a single transaction.
+    ///
+    /// Returns the rowids of the inserted entities in the same order as the
+    /// input. Empty input returns an empty vector without opening a
+    /// transaction. On any error, the transaction is rolled back and the
+    /// database is left untouched.
+    pub fn insert_entities_bulk(
+        &self,
+        entities: &[GraphEntity],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        if entities.is_empty() {
+            return Ok(Vec::new());
+        }
+        for entity in entities {
+            validate_entity(entity)?;
+        }
+        let conn = self.connection();
+        conn.underlying()
+            .execute_batch("BEGIN")
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+
+        let mut ids = Vec::with_capacity(entities.len());
+        let insert_result: Result<(), SqliteGraphError> = (|| {
+            let mut stmt = conn
+                .prepare_cached(
+                    "INSERT INTO graph_entities(kind, name, file_path, data) VALUES(?1, ?2, ?3, ?4)",
+                )
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+            for entity in entities {
+                let data = serde_json::to_string(&entity.data)
+                    .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
+                stmt.execute(params![
+                    entity.kind.as_str(),
+                    entity.name.as_str(),
+                    entity.file_path.as_deref(),
+                    data,
+                ])
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                ids.push(conn.last_insert_rowid());
+            }
+            Ok(())
+        })();
+
+        match insert_result {
+            Ok(()) => {
+                conn.underlying()
+                    .execute_batch("COMMIT")
+                    .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                Ok(ids)
+            }
+            Err(err) => {
+                let _ = conn.underlying().execute_batch("ROLLBACK");
+                Err(err)
+            }
+        }
+    }
+
     pub fn get_entity(&self, id: i64) -> Result<GraphEntity, SqliteGraphError> {
         self.connection()
             .query_row(

sqlitegraph-0.3.0/sqlitegraph-core/tests/bulk_insert_tests.rs

@@ -0,0 +1,173 @@
+//! Tests for bulk insert primitives on `SqliteGraph` and `GraphBackend`.
+
+use serde_json::json;
+use sqlitegraph::{
+    GraphEdge, GraphEntity, SqliteGraph, SqliteGraphBackend,
+    backend::{EdgeSpec, GraphBackend, NodeSpec},
+};
+
+fn entity(kind: &str, name: &str) -> GraphEntity {
+    GraphEntity {
+        id: 0,
+        kind: kind.to_string(),
+        name: name.to_string(),
+        file_path: None,
+        data: json!({}),
+    }
+}
+
+fn edge(from: i64, to: i64, kind: &str) -> GraphEdge {
+    GraphEdge {
+        id: 0,
+        from_id: from,
+        to_id: to,
+        edge_type: kind.to_string(),
+        data: json!({}),
+    }
+}
+
+fn node_spec(kind: &str, name: &str) -> NodeSpec {
+    NodeSpec {
+        kind: kind.to_string(),
+        name: name.to_string(),
+        file_path: None,
+        data: json!({}),
+    }
+}
+
+fn edge_spec(from: i64, to: i64, kind: &str) -> EdgeSpec {
+    EdgeSpec {
+        from: from,
+        to: to,
+        edge_type: kind.to_string(),
+        data: json!({}),
+    }
+}
+
+#[test]
+fn insert_entities_bulk_returns_ids_in_input_order() {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    let entities = vec![
+        entity("Function", "a"),
+        entity("Function", "b"),
+        entity("Function", "c"),
+    ];
+    let ids = graph
+        .insert_entities_bulk(&entities)
+        .expect("bulk insert entities");
+    assert_eq!(ids.len(), 3);
+    assert!(ids[0] < ids[1]);
+    assert!(ids[1] < ids[2]);
+    // Verify roundtrip
+    let stored = graph.get_entity(ids[1]).expect("get");
+    assert_eq!(stored.name, "b");
+}
+
+#[test]
+fn insert_entities_bulk_empty_input_returns_empty_vec() {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    let ids = graph.insert_entities_bulk(&[]).expect("bulk empty");
+    assert!(ids.is_empty());
+}
+
+#[test]
+fn insert_entities_bulk_rolls_back_on_error() {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    // Insert one valid entity to anchor a baseline count.
+    graph
+        .insert_entity(&entity("Function", "baseline"))
+        .unwrap();
+
+    // Build a batch where the second entity has an invalid (empty) name.
+    let entities = vec![
+        entity("Function", "valid_one"),
+        entity("Function", ""), // validate_entity rejects empty name
+        entity("Function", "valid_two"),
+    ];
+    let result = graph.insert_entities_bulk(&entities);
+    assert!(result.is_err(), "expected error for invalid entity");
+
+    // Count must remain 1 — the partial inserts in this batch were rolled back.
+    let ids = graph.list_entity_ids().unwrap();
+    assert_eq!(ids.len(), 1, "expected rollback to undo partial inserts");
+}
+
+#[test]
+fn insert_edges_bulk_returns_ids_in_input_order() {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    let a = graph.insert_entity(&entity("Node", "a")).unwrap();
+    let b = graph.insert_entity(&entity("Node", "b")).unwrap();
+    let c = graph.insert_entity(&entity("Node", "c")).unwrap();
+
+    let edges = vec![
+        edge(a, b, "CALL"),
+        edge(b, c, "CALL"),
+        edge(a, c, "IMPORTS"),
+    ];
+    let ids = graph.insert_edges_bulk(&edges).expect("bulk insert edges");
+    assert_eq!(ids.len(), 3);
+    assert!(ids[0] < ids[1]);
+    assert!(ids[1] < ids[2]);
+}
+
+#[test]
+fn insert_edges_bulk_empty_input_returns_empty_vec() {
+    let graph = SqliteGraph::open_in_memory().expect("graph");
+    let ids = graph.insert_edges_bulk(&[]).expect("bulk empty");
+    assert!(ids.is_empty());
+}
+
+#[test]
+fn graph_backend_insert_nodes_bulk_via_sqlite_backend() {
+    let backend = SqliteGraphBackend::in_memory().expect("backend");
+    let specs = vec![
+        node_spec("Function", "alpha"),
+        node_spec("Function", "beta"),
+        node_spec("Function", "gamma"),
+    ];
+    let ids = backend
+        .insert_nodes_bulk(&specs)
+        .expect("bulk insert nodes");
+    assert_eq!(ids.len(), 3);
+    assert!(ids[0] < ids[1]);
+}
+
+#[test]
+fn graph_backend_insert_edges_bulk_via_sqlite_backend() {
+    let backend = SqliteGraphBackend::in_memory().expect("backend");
+    let node_specs = vec![node_spec("Node", "a"), node_spec("Node", "b")];
+    let ids = backend.insert_nodes_bulk(&node_specs).expect("nodes");
+    let edge_specs = vec![edge_spec(ids[0], ids[1], "LINK")];
+    let edge_ids = backend
+        .insert_edges_bulk(&edge_specs)
+        .expect("bulk insert edges");
+    assert_eq!(edge_ids.len(), 1);
+}
+
+#[test]
+fn bulk_insert_matches_single_insert_observable_state() {
+    let single = SqliteGraph::open_in_memory().expect("single");
+    let bulk = SqliteGraph::open_in_memory().expect("bulk");
+
+    let entities = vec![
+        entity("Function", "a"),
+        entity("Function", "b"),
+        entity("Function", "c"),
+    ];
+    for e in &entities {
+        single.insert_entity(e).unwrap();
+    }
+    let bulk_ids = bulk.insert_entities_bulk(&entities).unwrap();
+
+    // Same observable state: same names, same kinds, same file_paths,
+    // same id ordering, same count.
+    assert_eq!(bulk_ids.len(), 3);
+    for (i, id) in bulk_ids.iter().enumerate() {
+        let stored = bulk.get_entity(*id).unwrap();
+        assert_eq!(stored.name, entities[i].name);
+        assert_eq!(stored.kind, entities[i].kind);
+    }
+    let bulk_count = bulk.list_entity_ids().unwrap().len();
+    let single_count = single.list_entity_ids().unwrap().len();
+    assert_eq!(bulk_count, single_count);
+}

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

@@ -3,6 +3,27 @@
 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.3.0] - 2026-05-16
+
+### Added
+- **`Graph.add_nodes_bulk(items: list[dict])`** — Insert many nodes in a
+  single FFI call inside one transaction. Each dict must have `kind` and
+  `name`; `data` (dict) and `file_path` (str) are optional. Returns
+  IDs in input order.
+- **`Graph.add_edges_bulk(items: list[dict])`** — Insert many edges in a
+  single FFI call inside one transaction. Each dict must have `from_id`,
+  `to_id`, and `edge_type`; `data` (dict) is optional. Returns IDs in
+  input order.
+- **10 new pytest cases** in `tests/test_bulk_insert.py` covering both
+  bulk paths, missing-field validation, data round-trip, and parity
+  with per-item single-insert.
+
+### Notes
+- Built against `sqlitegraph` (Rust) **v2.4.0**, which adds the
+  underlying `GraphBackend::insert_nodes_bulk` and `insert_edges_bulk`
+  trait methods.
+- All existing `add_node`/`add_edge` signatures are unchanged.
+
 ## [0.2.0] - 2026-05-15
 
 ### Added

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

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

{sqlitegraph-0.2.0 → sqlitegraph-0.3.0}/sqlitegraph-py/src/lib.rs

@@ -133,6 +133,51 @@ impl Graph {
         self.backend.insert_node(spec).map_err(into_pyerr)
     }
 
+    /// Insert many nodes atomically inside a single transaction.
+    ///
+    /// Args:
+    ///     items: List of dicts, each with `kind` and `name` (required) plus
+    ///         optional `data` (dict) and `file_path` (str).
+    ///
+    /// Returns:
+    ///     List of new node IDs in the same order as ``items``.
+    ///
+    /// Raises:
+    ///     InvalidArgumentError if any item is missing required fields or
+    ///     fails validation. On error the transaction is rolled back; no
+    ///     nodes are inserted.
+    fn add_nodes_bulk(&self, items: Vec<Bound<'_, PyDict>>) -> PyResult<Vec<i64>> {
+        let mut specs = Vec::with_capacity(items.len());
+        for item in items.iter() {
+            let kind: String = item
+                .get_item("kind")?
+                .ok_or_else(|| InvalidArgumentError::new_err("each item must have a 'kind' field"))?
+                .extract()?;
+            let name: String = item
+                .get_item("name")?
+                .ok_or_else(|| InvalidArgumentError::new_err("each item must have a 'name' field"))?
+                .extract()?;
+            let file_path: Option<String> = match item.get_item("file_path")? {
+                Some(v) if !v.is_none() => Some(v.extract()?),
+                _ => None,
+            };
+            let data = match item.get_item("data")? {
+                Some(v) if !v.is_none() => {
+                    let dict = v.cast::<PyDict>()?;
+                    dict_to_json(dict)?
+                }
+                _ => serde_json::json!({}),
+            };
+            specs.push(NodeSpec {
+                kind,
+                name,
+                file_path,
+                data,
+            });
+        }
+        self.backend.insert_nodes_bulk(&specs).map_err(into_pyerr)
+    }
+
     /// Get a node by ID. Returns a dict with keys: id, kind, name, data.
     fn get_node<'py>(&self, py: Python<'py>, id: i64) -> PyResult<Bound<'py, PyDict>> {
         let entity = self
@@ -230,6 +275,57 @@ impl Graph {
         self.backend.insert_edge(spec).map_err(into_pyerr)
     }
 
+    /// Insert many edges atomically inside a single transaction.
+    ///
+    /// Args:
+    ///     items: List of dicts, each with `from_id`, `to_id`, and
+    ///         `edge_type` (all required) plus optional `data` (dict).
+    ///
+    /// Returns:
+    ///     List of new edge IDs in the same order as ``items``.
+    ///
+    /// Raises:
+    ///     InvalidArgumentError if any item is missing required fields or
+    ///     references non-existent endpoints. On error the transaction is
+    ///     rolled back; no edges are inserted.
+    fn add_edges_bulk(&self, items: Vec<Bound<'_, PyDict>>) -> PyResult<Vec<i64>> {
+        let mut specs = Vec::with_capacity(items.len());
+        for item in items.iter() {
+            let from_id: i64 = item
+                .get_item("from_id")?
+                .ok_or_else(|| {
+                    InvalidArgumentError::new_err("each item must have a 'from_id' field")
+                })?
+                .extract()?;
+            let to_id: i64 = item
+                .get_item("to_id")?
+                .ok_or_else(|| {
+                    InvalidArgumentError::new_err("each item must have a 'to_id' field")
+                })?
+                .extract()?;
+            let edge_type: String = item
+                .get_item("edge_type")?
+                .ok_or_else(|| {
+                    InvalidArgumentError::new_err("each item must have an 'edge_type' field")
+                })?
+                .extract()?;
+            let data = match item.get_item("data")? {
+                Some(v) if !v.is_none() => {
+                    let dict = v.cast::<PyDict>()?;
+                    dict_to_json(dict)?
+                }
+                _ => serde_json::json!({}),
+            };
+            specs.push(EdgeSpec {
+                from: from_id,
+                to: to_id,
+                edge_type,
+                data,
+            });
+        }
+        self.backend.insert_edges_bulk(&specs).map_err(into_pyerr)
+    }
+
     /// Get neighbors of a node.
     ///
     /// Args: