iris-vector-graph 1.91.2__tar.gz → 1.91.4__tar.gz

{iris_vector_graph-1.91.2 → iris_vector_graph-1.91.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.91.2
+Version: 1.91.4
 Summary: Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs
 Project-URL: Homepage, https://github.com/intersystems-community/iris-vector-graph
 Project-URL: Documentation, https://github.com/intersystems-community/iris-vector-graph/tree/main/docs

{iris_vector_graph-1.91.2 → iris_vector_graph-1.91.4}/iris_vector_graph/cypher_api.py

@@ -18,9 +18,11 @@ from pathlib import Path
 from pydantic import BaseModel, Field
 
 try:
+    from iris_vector_graph.embedded import _ensure_embedded_iris_first
+    _ensure_embedded_iris_first()
     import iris
-    _EMBEDDED = True
-except ImportError:
+    _EMBEDDED = hasattr(iris, 'cls')
+except (ImportError, Exception):
     _EMBEDDED = False
 
 from contextlib import asynccontextmanager

{iris_vector_graph-1.91.2 → iris_vector_graph-1.91.4}/iris_vector_graph/engine.py

@@ -879,14 +879,19 @@ class IRISGraphEngine:
 
     def _assert_node_exists(self, node_id: str) -> None:
         cursor = self.conn.cursor()
-        # Use constant table names or sanitized identifiers
-        table = validate_table_name("nodes")
-        cursor.execute(
-            f"SELECT COUNT(*) FROM Graph_KG.{table} WHERE node_id = ?", [node_id]
-        )
-        result = cursor.fetchone()
-        if not result or result[0] == 0:
-            raise ValueError(f"Node does not exist: {node_id}")
+        try:
+            cursor.execute(
+                f"SELECT COUNT(*) FROM {_table('nodes')} WHERE node_id = ?", [node_id]
+            )
+            result = cursor.fetchone()
+            if not result or result[0] == 0:
+                raise ValueError(f"Node does not exist: {node_id}")
+        except ValueError:
+            raise
+        except Exception:
+            pass
+        finally:
+            cursor.close()
 
     def execute_cypher(
         self, cypher_query: str, parameters: Dict[str, Any] = None,
@@ -5091,69 +5096,89 @@ class IRISGraphEngine:
     def _kg_KNN_VEC_python_optimized(
         self, query_vector: str, k: int = 50, label_filter: Optional[str] = None
     ) -> List[Tuple[str, float]]:
-        """
-        Fallback Python implementation using CSV parsing
-        Performance: ~5.8s for 20K vectors (when HNSW not available)
-        """
+        _dtype = getattr(self, 'vector_dtype', 'DOUBLE')
+        emb_table = _table("kg_NodeEmbeddings")
+        labels_table = _table("rdf_labels")
+
+        if label_filter:
+            sql = (
+                f"SELECT TOP {int(k)} n.id, VECTOR_COSINE(n.emb, TO_VECTOR(?, {_dtype})) AS score"
+                f" FROM {emb_table} n"
+                f" LEFT JOIN {labels_table} L ON L.s = n.id"
+                f" WHERE L.label = ?"
+                f" ORDER BY score DESC"
+            )
+            params = [query_vector, label_filter]
+        else:
+            sql = (
+                f"SELECT TOP {int(k)} n.id, VECTOR_COSINE(n.emb, TO_VECTOR(?, {_dtype})) AS score"
+                f" FROM {emb_table} n"
+                f" ORDER BY score DESC"
+            )
+            params = [query_vector]
+
+        try:
+            from iris_vector_graph.embedded import _sql_statement_execute, _is_ddtab_error
+            rs = _sql_statement_execute(sql, params)
+            results = [(row[0], float(row[1])) for row in rs if row[0] is not None]
+            return results
+        except Exception:
+            pass
+
+        try:
+            cursor = self.conn.cursor()
+            cursor.execute(sql, params)
+            results = [(row[0], float(row[1])) for row in cursor.fetchall()]
+            cursor.close()
+            return results
+        except Exception:
+            pass
+
+        return self._kg_KNN_VEC_client_side(query_vector, k, label_filter)
+
+    def _kg_KNN_VEC_client_side(
+        self, query_vector: str, k: int = 50, label_filter: Optional[str] = None
+    ) -> List[Tuple[str, float]]:
         cursor = self.conn.cursor()
         try:
             import numpy as np
 
             query_array = np.array(json.loads(query_vector))
 
-            # Get embeddings with optional label filter (optimized query)
             emb_table = _table("kg_NodeEmbeddings")
             labels_table = _table("rdf_labels")
             if label_filter is None:
-                sql = f"""
-                    SELECT n.id, n.emb
-                    FROM {emb_table} n
-                    WHERE n.emb IS NOT NULL
-                """
-                cursor.execute(sql)
+                cursor.execute(f"SELECT n.id, n.emb FROM {emb_table} n WHERE n.emb IS NOT NULL")
             else:
-                sql = f"""
-                    SELECT n.id, n.emb
-                    FROM {emb_table} n
-                    LEFT JOIN {labels_table} L ON L.s = n.id
-                    WHERE n.emb IS NOT NULL
-                      AND L.label = ?
-                """
-                cursor.execute(sql, [label_filter])
-
-            # Compute similarities efficiently
-            similarities = []
-            batch_size = 1000  # Process in batches for memory efficiency
+                cursor.execute(
+                    f"SELECT n.id, n.emb FROM {emb_table} n"
+                    f" LEFT JOIN {labels_table} L ON L.s = n.id"
+                    f" WHERE n.emb IS NOT NULL AND L.label = ?",
+                    [label_filter],
+                )
 
+            similarities = []
             while True:
-                batch = cursor.fetchmany(batch_size)
+                batch = cursor.fetchmany(1000)
                 if not batch:
                     break
-
                 for entity_id, emb_csv in batch:
                     try:
-                        # Fast CSV parsing to numpy array
-                        emb_array = np.fromstring(emb_csv, dtype=float, sep=",")
-
-                        # Compute cosine similarity efficiently
+                        emb_array = np.fromstring(str(emb_csv), dtype=float, sep=",")
                         dot_product = np.dot(query_array, emb_array)
                         query_norm = np.linalg.norm(query_array)
                         emb_norm = np.linalg.norm(emb_array)
-
                         if query_norm > 0 and emb_norm > 0:
                             cos_sim = dot_product / (query_norm * emb_norm)
                             similarities.append((entity_id, float(cos_sim)))
-
                     except Exception:
-                        # Skip problematic embeddings
                         continue
 
-            # Sort by similarity and return top k
             similarities.sort(key=lambda x: x[1], reverse=True)
             return similarities[:k]
 
         except Exception as e:
-            logger.error(f"Python optimized kg_KNN_VEC failed: {e}")
+            logger.error(f"Client-side kg_KNN_VEC failed: {e}")
             raise
         finally:
             cursor.close()
@@ -6790,7 +6815,9 @@ class IRISGraphEngine:
 
     def get_node_properties(self, node_id: str) -> Dict[str, Any]:
         node = self.get_node(node_id)
-        return node.get("properties", {}) if node else {}
+        if not node:
+            return {}
+        return {k: v for k, v in node.items() if k not in ("id", "labels")}
 
     def get_node_name(self, node_id: str) -> Optional[str]:
         props = self.get_node_properties(node_id)
@@ -6827,11 +6854,12 @@ class IRISGraphEngine:
         cursor = self.conn.cursor()
         try:
             cursor.execute(
-                f"INSERT OR IGNORE INTO {_table('nodes')} (node_id) VALUES (?)", [node_id]
+                f"INSERT INTO {_table('nodes')} (node_id) VALUES (?)", [node_id]
             )
             self.conn.commit()
-        except Exception:
-            pass
+        except Exception as e:
+            if "-119" not in str(e) and "duplicate" not in str(e).lower():
+                raise
         finally:
             cursor.close()
         if properties:
@@ -6840,7 +6868,11 @@ class IRISGraphEngine:
                 cursor2 = self.conn.cursor()
                 try:
                     cursor2.execute(
-                        f"INSERT OR REPLACE INTO {_table('rdf_props')} (s, \"key\", val) VALUES (?, ?, ?)",
+                        f"DELETE FROM {_table('rdf_props')} WHERE s = ? AND \"key\" = ?",
+                        [node_id, k]
+                    )
+                    cursor2.execute(
+                        f"INSERT INTO {_table('rdf_props')} (s, \"key\", val) VALUES (?, ?, ?)",
                         [node_id, k, val_str]
                     )
                     self.conn.commit()
@@ -6853,12 +6885,64 @@ class IRISGraphEngine:
                 cursor3 = self.conn.cursor()
                 try:
                     cursor3.execute(
-                        f"INSERT OR IGNORE INTO {_table('rdf_labels')} (s, label) VALUES (?, ?)",
+                        f"INSERT INTO {_table('rdf_labels')} (s, label) VALUES (?, ?)",
                         [node_id, lbl]
                     )
                     self.conn.commit()
-                except Exception:
-                    pass
+                except Exception as e:
+                    if "-119" not in str(e) and "duplicate" not in str(e).lower():
+                        raise
                 finally:
                     cursor3.close()
         return True
+
+    def store_edge(self, source_id: str, predicate: str, target_id: str,
+                   qualifiers: Optional[Dict[str, Any]] = None) -> bool:
+        self.store_node(source_id)
+        self.store_node(target_id)
+        cursor = self.conn.cursor()
+        try:
+            qual_json = json.dumps(qualifiers) if qualifiers else None
+            cursor.execute(
+                f"INSERT INTO {_table('rdf_edges')} (s, p, o_id, qualifiers) VALUES (?, ?, ?, ?)",
+                [source_id, predicate, target_id, qual_json],
+            )
+            self.conn.commit()
+        except Exception as e:
+            if "-119" not in str(e) and "duplicate" not in str(e).lower():
+                raise
+        finally:
+            cursor.close()
+        return True
+
+    def nodes_exist(self, node_ids: List[str]) -> set:
+        if not node_ids:
+            return set()
+        existing: set = set()
+        cursor = self.conn.cursor()
+        try:
+            for i in range(0, len(node_ids), 200):
+                batch = node_ids[i:i + 200]
+                phs = ",".join(["?"] * len(batch))
+                try:
+                    cursor.execute(
+                        f"SELECT node_id FROM {_table('nodes')} WHERE node_id IN ({phs})",
+                        batch,
+                    )
+                    for row in cursor.fetchall():
+                        existing.add(row[0])
+                except Exception:
+                    for nid in batch:
+                        try:
+                            cursor.execute(
+                                f"SELECT COUNT(*) FROM {_table('nodes')} WHERE node_id = ?",
+                                [nid],
+                            )
+                            row = cursor.fetchone()
+                            if row and int(row[0]) > 0:
+                                existing.add(nid)
+                        except Exception:
+                            pass
+        finally:
+            cursor.close()
+        return existing

{iris_vector_graph-1.91.2 → iris_vector_graph-1.91.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "1.91.2"
+version = "1.91.4"
 description = "Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs"
 readme = "README.md"
 license = "MIT"