iris-vector-graph 2.4.2__tar.gz → 2.4.5__tar.gz

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 2.4.2
-Summary: Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs
+Version: 2.4.5
+Summary: Native graph database layer for InterSystems IRIS — openCypher, hybrid vector search, temporal property graph, RDF export, SHACL validation
 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
 Project-URL: Repository, https://github.com/intersystems-community/iris-vector-graph
@@ -92,7 +92,7 @@ Description-Content-Type: text/markdown
 
 # iris-vector-graph
 
-**Knowledge graph engine for InterSystems IRIS** — openCypher queries, temporal property graph, vector search, and graph analytics.
+**Turn InterSystems IRIS into a graph + vector database** — openCypher queries, HNSW/BM25 hybrid search, temporal property graph, RDF/SHACL/PROV-O semantic layer, and Neo4j Bolt protocol compatibility.
 
 [![PyPI](https://img.shields.io/pypi/v/iris-vector-graph)](https://pypi.org/project/iris-vector-graph/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/README.md

@@ -1,6 +1,6 @@
 # iris-vector-graph
 
-**Knowledge graph engine for InterSystems IRIS** — openCypher queries, temporal property graph, vector search, and graph analytics.
+**Turn InterSystems IRIS into a graph + vector database** — openCypher queries, HNSW/BM25 hybrid search, temporal property graph, RDF/SHACL/PROV-O semantic layer, and Neo4j Bolt protocol compatibility.
 
 [![PyPI](https://img.shields.io/pypi/v/iris-vector-graph)](https://pypi.org/project/iris-vector-graph/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_src/src/Graph/KG/NKGAccelAdjacency.cls

@@ -236,7 +236,7 @@ ClassMethod ExportAdjacencyFromSeed(seed As %String, maxHops As %Integer = 4, pr
     Kill ^||seedBFS
     Return result
 }
-ClassMethod ExportAdjacencyWithPreds(requiredPreds As %List = "") As %String [ Private ]
+ClassMethod ExportAdjacencyWithPreds(requiredPreds As %List = "") As %String
 {
     Set hasGuard = (requiredPreds '= "") && ($ListLength(requiredPreds) > 0)
     Set result = "", chunk = "", chunkNum = 0
@@ -282,7 +282,7 @@ ClassMethod ExportAdjacencyWithPreds(requiredPreds As %List = "") As %String [ P
     }
     Return result
 }
-ClassMethod StoreLargeOut(tag As %String, json As %String) As %String [ Private ]
+ClassMethod StoreLargeOut(tag As %String, json As %String) As %String
 {
     If $Length(json) <= 9000 { Return json }
     Kill ^||LargeOut(tag)

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_src/src/Graph/KG/NKGAccelTraversal.cls

@@ -356,10 +356,19 @@ ClassMethod BFSJson(seed As %String, predicatesJson As %String = "[]", maxHops A
         Return ##class(Graph.KG.Traversal).BFSFastJsonSorted(seed, predicatesJson, maxHops, "", "out", maxResults)
     }
     Set adjStr = ##class(Graph.KG.NKGAccelAdjacency).ExportAdjacencyWithPreds()
-    Set raw = $ZF(-5, dllid, fnid, adjStr, seed, predicatesJson, maxHops, maxResults)
+    Set resultGlobal = "ArnoKG"
+    Kill ^ArnoKG("bfs_result")
+    Set raw = $ZF(-5, dllid, fnid, adjStr, resultGlobal, seed, predicatesJson, maxHops, maxResults)
     If raw = "" || $Extract(raw, 1, 6) = "DEBUG:" {
         Return ##class(Graph.KG.Traversal).BFSFastJsonSorted(seed, predicatesJson, maxHops, "", "out", maxResults)
     }
+    If $Extract(raw, 1, 10) = "CHUNKED:BFS" {
+        Set n = +$Piece(raw, ":", 3)
+        Set json = ""
+        For i = 1:1:n { Set json = json _ $Get(^ArnoKG("bfs_result", i), "") }
+        Kill ^ArnoKG("bfs_result")
+        Set raw = json
+    }
     Set tag = $Job _ "_bfs"
     Kill ^ArnoKG("bfs_r", tag)
     Set arr = ##class(%DynamicArray).%FromJSON(raw)

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_vector_graph/_engine/embeddings.py

@@ -79,17 +79,20 @@ class EmbeddingsMixin:
     def _get_embedding_dimension(self) -> int:
         """
         Get the vector embedding dimension, either from initialization or auto-detection.
-        Prioritizes database detection if the schema exists.
+        Prioritizes the already-known instance value to avoid a per-call class-dictionary
+        query — querying %Dictionary.CompiledProperty on every write contends for the
+        class's Class-Changed_Timestamp and can raise SQLCODE -150 (optimistic concurrency
+        locking failure) under concurrent writers.
         """
-        cursor = self.conn.cursor()
+        # 1. Fast path: caller already provided it, or a prior DB detection cached it here.
+        if self.embedding_dimension is not None:
+            return self.embedding_dimension
 
-        # 1. Try to detect from DB first
+        # 2. Fall back to DB detection only when the dimension is truly unknown.
+        cursor = self.conn.cursor()
         dim = GraphSchema.get_embedding_dimension(cursor)
         if dim:
-            return int(dim)
-
-        # 2. Fallback to instance variable if DB detection fails or table doesn't exist
-        if self.embedding_dimension is not None:
+            self.embedding_dimension = int(dim)
             return self.embedding_dimension
 
         raise ValueError(

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_vector_graph/_engine/nodes_edges.py

@@ -372,6 +372,43 @@ class NodesEdgesMixin:
             return 0
 
 
+    def get_node_ids_by_label(self, label: str) -> List[str]:
+        """
+        Return all node IDs with the given label via a direct rdf_labels scan.
+
+        Mirrors Neo4j's NodeByLabelScan: label-membership lookup is a distinct,
+        common-enough access pattern to warrant its own primitive rather than
+        going through the Cypher MATCH translator, whose generated multi-table
+        JOIN can hit the IRIS %qaqpre compiler fault on some builds/instances.
+
+        Args:
+            label: Label to filter by.
+
+        Returns:
+            List of node IDs (empty list if none match).
+        """
+        cursor = self.conn.cursor()
+        cursor.execute(f"SELECT s FROM {_table('rdf_labels')} WHERE label = ?", [label])
+        return [row[0] for row in cursor.fetchall() if row and row[0]]
+
+
+    def get_nodes_by_label(self, label: str) -> List[Dict[str, Any]]:
+        """
+        Return hydrated nodes (id, labels, properties) with the given label.
+
+        Equivalent to get_node_ids_by_label + get_nodes, avoiding the JOIN-based
+        Cypher MATCH translation path.
+
+        Args:
+            label: Label to filter by.
+
+        Returns:
+            List of node dicts (see get_nodes), empty list if none match.
+        """
+        ids = self.get_node_ids_by_label(label)
+        return self.get_nodes(ids) if ids else []
+
+
     def create_node(
         self, node_id: str, labels: List[str] = None, properties: Dict[str, Any] = None,
         graph: Optional[str] = None,

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_vector_graph/_engine/query.py

@@ -355,8 +355,11 @@ class QueryMixin:
         max_hops = vl0.get("max_hops", 5)
         direction = vl0.get("direction", "out")
         def _extract_limit(s: str) -> int:
-            # IRIS SQL uses FETCH FIRST N ROWS ONLY; fall back to LIMIT N
+            # IRIS SQL uses FETCH FIRST N ROWS ONLY; the build-106 %qaqpre workaround
+            # emits SELECT TOP N instead; fall back to LIMIT N.
             m = _re.search(r"FETCH\s+FIRST\s+(\d+)\s+ROWS\s+ONLY", s, _re.IGNORECASE)
+            if not m:
+                m = _re.search(r"\bSELECT\s+(?:DISTINCT\s+)?TOP\s+(\d+)\b", s, _re.IGNORECASE)
             if not m:
                 m = _re.search(r"\bLIMIT\s+(\d+)", s, _re.IGNORECASE)
             return int(m.group(1)) if m else 0
@@ -563,8 +566,11 @@ class QueryMixin:
         import re as _re
         sql_str = sql_query.sql if isinstance(sql_query.sql, str) else (sql_query.sql[0] if sql_query.sql else "")
         if sql_query.sql:
-            # IRIS SQL uses "FETCH FIRST N ROWS ONLY" (not LIMIT N)
+            # IRIS SQL uses "FETCH FIRST N ROWS ONLY"; the build-106 %qaqpre workaround
+            # emits SELECT TOP N instead; fall back to LIMIT N.
             m = _re.search(r"FETCH\s+FIRST\s+(\d+)\s+ROWS\s+ONLY", sql_str, _re.IGNORECASE)
+            if not m:
+                m = _re.search(r"\bSELECT\s+(?:DISTINCT\s+)?TOP\s+(\d+)\b", sql_str, _re.IGNORECASE)
             if not m:
                 m = _re.search(r"\bLIMIT\s+(\d+)", sql_str, _re.IGNORECASE)
             if m:

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_vector_graph/cypher/translator.py

@@ -1044,9 +1044,14 @@ def _maybe_split_deep_joins(sql: str, params: list, context) -> str:
     if join_count <= JOIN_THRESHOLD:
         return sql
     import re as _re
-    select_m = _re.match(r'(SELECT\s+(?:DISTINCT\s+)?)(.*?)(\nFROM\s)', sql, _re.DOTALL)
+    # Capture an optional `TOP n` in the prefix (the FETCH-FIRST-+-JOIN workaround emits
+    # SELECT [DISTINCT] TOP n) so it stays attached to the SELECT keyword and is not
+    # swept into the column list.
+    select_m = _re.match(r'(SELECT\s+(?:DISTINCT\s+)?(?:TOP\s+\d+\s+)?)(.*?)(\nFROM\s)', sql, _re.DOTALL)
     if not select_m:
         return sql
+    # select_prefix carries any DISTINCT and TOP n; both propagate to the outer wrapper
+    # (line below), so the CTE wrap preserves the row cap from the TOP workaround.
     select_prefix = select_m.group(1)
     select_cols = select_m.group(2).strip()
     has_agg = bool(_re.search(r'\b(AVG|SUM|COUNT|MIN|MAX|STDEV|JSON_ARRAYAGG)\s*\(', select_cols))
@@ -1543,6 +1548,27 @@ def apply_pagination(
     if limit is not None or skip is not None:
         if "\nFROM " not in sql and "FROM " not in sql.split("\n")[0]:
             sql = sql.rstrip() + "\nFROM (SELECT 1) __dual"
+    # Build-106 workaround: IRIS 2026.3.0AI build 106 SIGSEGVs in %qaqpre when a
+    # multi-table JOIN is combined with `FETCH FIRST n ROWS ONLY` on VARCHAR-keyed
+    # tables (the ivg schema). `SELECT TOP n` does NOT crash. When the engine has
+    # detected the bug (engine._fetch_first_unsafe, set by a connect-time probe) and
+    # there is a LIMIT with NO SKIP (TOP cannot express OFFSET), emit TOP instead.
+    engine = getattr(context, "_engine", None)
+    fetch_first_unsafe = bool(getattr(engine, "_fetch_first_unsafe", False))
+    if (
+        limit is not None
+        and skip is None
+        and fetch_first_unsafe
+        and sql.lstrip().upper().startswith("SELECT ")
+        and " TOP " not in sql.split("\n", 1)[0].upper()
+    ):
+        # Inject `TOP n` right after the leading SELECT (and after DISTINCT if present).
+        head, sep, rest = sql.partition("SELECT ")
+        if rest[:9].upper().startswith("DISTINCT "):
+            rest = "DISTINCT " + f"TOP {limit} " + rest[9:]
+        else:
+            rest = f"TOP {limit} " + rest
+        return head + sep + rest
     if limit is not None:
         sql += f"\nFETCH FIRST {limit} ROWS ONLY"
     if skip is not None:

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_vector_graph/engine.py

@@ -143,6 +143,7 @@ class IRISGraphEngine(RdfExportMixin, ShaclMixin, ProvMixin, TemporalMixin, Snap
         self._rel_mapping_cache: Optional[Dict[tuple, dict]] = None
         self._connection_params: Optional[Dict[str, Any]] = None
         self._nkg_dirty: bool = False
+        self._fetch_first_unsafe_cached: Optional[bool] = None  # build-106 %qaqpre probe (lazy)
         self._native_conn = None  # dedicated connection for iris.createIRIS — never used for cursor DDL
         self._index_registry: Dict[str, str] = self._build_index_registry()
         self._pending_index_config: Dict[str, Any] = {}
@@ -209,6 +210,69 @@ class IRISGraphEngine(RdfExportMixin, ShaclMixin, ProvMixin, TemporalMixin, Snap
             )
         return cls(conn, embedding_dimension=embedding_dimension, **kwargs)
 
+    @property
+    def _fetch_first_unsafe(self) -> bool:
+        """True when this IRIS build SIGSEGVs in %qaqpre on a multi-table JOIN combined
+        with `FETCH FIRST n ROWS ONLY` (observed on irishealth 2026.3.0AI build 106).
+
+        Detected once and cached. Primary signal is a behavioral probe run in a
+        SUBPROCESS (the crash is a hard SIGSEGV — uncatchable in-process), gated on
+        having stored connection params. Falls back to a $ZVERSION build check when a
+        subprocess probe is not possible (e.g. embedded context). Defaults to safe
+        (False) if neither can determine — `TOP` is only a workaround, never required.
+        """
+        if self._fetch_first_unsafe_cached is None:
+            self._fetch_first_unsafe_cached = self._detect_fetch_first_unsafe()
+        return self._fetch_first_unsafe_cached
+
+    def _detect_fetch_first_unsafe(self) -> bool:
+        # Subprocess behavioral probe (most reliable): run the crashing shape against a
+        # VARCHAR-keyed temp table; SIGSEGV (rc -11 / 139) => unsafe.
+        if self._connection_params:
+            try:
+                import subprocess, sys, json
+                cp = json.dumps(self._connection_params)
+                script = (
+                    "import iris, json, sys\n"
+                    f"cp = json.loads(r'''{cp}''')\n"
+                    "c = iris.dbapi.connect(**cp); cur = c.cursor()\n"
+                    "for d in ['CREATE TABLE ivg_ff_probe_a (id VARCHAR(64))',"
+                    "'CREATE TABLE ivg_ff_probe_b (sid VARCHAR(64))']:\n"
+                    "    try: cur.execute(d)\n"
+                    "    except Exception: pass\n"
+                    "cur.execute('SELECT a.id FROM ivg_ff_probe_a a JOIN ivg_ff_probe_b b "
+                    "ON b.sid=a.id FETCH FIRST 1 ROWS ONLY'); cur.fetchall()\n"
+                    "print('OK')\n"
+                )
+                r = subprocess.run([sys.executable, "-c", script],
+                                   capture_output=True, text=True, timeout=60)
+                if r.returncode in (-11, 139, -6, 134):
+                    logger.warning(
+                        "IRIS build SIGSEGVs in %%qaqpre on FETCH FIRST + multi-table JOIN "
+                        "(observed on 2026.2.0AI and 2026.3.0AI AI builds); ivg will emit "
+                        "TOP for LIMIT-only queries to avoid the crash."
+                    )
+                    return True
+                return False
+            except Exception as e:
+                logger.debug("fetch-first probe failed, falling back to version check: %s", e)
+        # Fallback: $ZVERSION check (no crash risk) when a subprocess probe is not
+        # possible (e.g. embedded context with no stored connection params). The bug
+        # has been observed on the IRIS "AI" build line (2026.2.0AI build 161 and
+        # 2026.3.0AI build 106); treat AI builds as unsafe conservatively. Non-AI
+        # builds are assumed safe (FETCH FIRST retained). If a future build fixes it,
+        # this fallback can be narrowed — the subprocess probe remains authoritative.
+        try:
+            cur = self.conn.cursor()
+            cur.execute("SELECT $ZVERSION")
+            ver = str(cur.fetchone()[0])
+            import re as _re
+            if _re.search(r"20\d\d\.\d+\.\d+AI", ver):
+                return True
+        except Exception:
+            pass
+        return False
+
     def _reconnect_if_stale(self) -> None:
         try:
             cur = self.conn.cursor()

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/iris_vector_graph/index_protocol.py

@@ -25,7 +25,9 @@ _BUILD = {
     "fulltext": lambda e, name, kw: e._build_fulltext_index(name, **kw),
     "multivector": lambda e, name, kw: e._build_multivector_index(name, **kw),
     "neighborhood_vector": lambda e, name, kw: e._build_neighborhood_index(name, **kw),
-    "hnsw": lambda e, name, kw: {"type": "hnsw", "available": e._probe_native_vec()},
+    "hnsw": lambda e, name, kw: {
+        "type": "hnsw", "available": e._probe_native_vec(), "rows": e.embedding_count(),
+    },
 }
 _SEARCH = {
     "vector": lambda e, name, q, k, kw: e._search_vector_index(name, q, k, **kw),
@@ -53,12 +55,14 @@ _INFO = {
     "fulltext": lambda e, name: e.bm25_info(name),
     "multivector": lambda e, name: e.plaid_info(name),
     "neighborhood_vector": lambda e, name: e._neighborhood_index_info(name),
-    "hnsw": lambda e, name: {"type": "hnsw", "available": e._probe_native_vec()},
+    "hnsw": lambda e, name: {
+        "type": "hnsw", "available": e._probe_native_vec(), "rows": e.embedding_count(),
+    },
 }
 
 
 def _rows_of(info: dict) -> int:
-    for key in ("rows", "count", "num_vectors", "indexed", "n_docs", "size", "total"):
+    for key in ("rows", "count", "num_vectors", "indexed", "n_docs", "size", "total", "N"):
         if key in info:
             try:
                 return int(info[key])

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "2.4.2"
-description = "Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs"
+version = "2.4.5"
+description = "Native graph database layer for InterSystems IRIS — openCypher, hybrid vector search, temporal property graph, RDF export, SHACL validation"
 readme = "README.md"
 license = "MIT"
 authors = [

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/benchmarks/bench.py

@@ -24,6 +24,7 @@ IRIS_PORT = int(os.environ.get("IRIS_PORT", "1972"))
 IRIS_NS   = os.environ.get("IRIS_NAMESPACE", "USER")
 IRIS_USER = os.environ.get("IRIS_USERNAME", "_SYSTEM")
 IRIS_PASS = os.environ.get("IRIS_PASSWORD", "SYS")
+ARNO_LIB  = os.environ.get("ARNO_LIB", "/usr/irissys/mgr/libarno_callout.so")
 
 
 def connect_iris():
@@ -195,7 +196,7 @@ def main():
             print(f"  Load complete: ^KG built in {load_info['kg_build_ms']}ms, ^NKG: {load_info['nkg_build_ms']}ms")
             try:
                 iris_obj.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
-                iris_obj.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+                iris_obj.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
                 iris_obj.classMethodVoid("Graph.KG.NKGAccel", "InvalidateAdjCache")
             except Exception:
                 pass
@@ -204,7 +205,7 @@ def main():
             try:
                 iris_obj.classMethodValue("Graph.KG.Traversal", "BuildNKG")
                 iris_obj.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
-                iris_obj.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+                iris_obj.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
                 print("  ^NKG rebuilt, arno reloaded")
             except Exception as e:
                 print(f"  NKG rebuild skipped: {e}")

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/benchmarks/bench_193_full.py

@@ -57,6 +57,9 @@ SEP2 = "-" * 68
 # Connection helpers
 # ---------------------------------------------------------------------------
 
+ARNO_LIB = os.environ.get("ARNO_LIB", "/usr/irissys/mgr/libarno_callout.so")
+
+
 def _connect(port, user="_SYSTEM", pw="SYS", ns="USER"):
     import iris
     host = os.environ.get("IRIS_HOST", "localhost")
@@ -518,8 +521,7 @@ def main():
             try:
                 iris_obj.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
                 iris_obj.classMethodValue(
-                    "Graph.KG.NKGAccel", "Load",
-                    "/usr/irissys/mgr/libarno_callout.so")
+                    "Graph.KG.NKGAccel", "Load", ARNO_LIB)
                 iris_obj.classMethodVoid("Graph.KG.NKGAccel", "InvalidateAdjCache")
             except Exception:
                 pass
@@ -593,8 +595,7 @@ def main():
                     try:
                         eiris.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
                         eiris.classMethodValue(
-                            "Graph.KG.NKGAccel", "Load",
-                            "/usr/irissys/mgr/libarno_callout.so")
+                            "Graph.KG.NKGAccel", "Load", ARNO_LIB)
                     except Exception:
                         pass
 

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/conftest.py

@@ -208,7 +208,9 @@ def iris_connection(iris_test_container):
                 cur.close()
 
     try:
-        eng = IRISGraphEngine(conn, embedding_dimension=128)
+        # 768 matches schema.py's own default (get_base_schema_sql) and what
+        # most of the e2e/integration suite assumes for kg_NodeEmbeddings.
+        eng = IRISGraphEngine(conn, embedding_dimension=768)
         eng.initialize_schema(auto_deploy_objectscript=False)
     except Exception as e:
         logger.warning("Schema init failed (may already exist): %s", e)
@@ -302,7 +304,7 @@ def arno_iris_connection():
     _primary = os.environ.get("IVG_TEST_CONTAINER", "ivg-iris")
     if _primary != _ARNO_CONTAINER:
         try:
-            IRISGraphEngine(conn, embedding_dimension=128).initialize_schema()
+            IRISGraphEngine(conn, embedding_dimension=768).initialize_schema()
         except Exception as e:
             logger.warning("arno container schema init: %s", e)
 
@@ -312,7 +314,20 @@ def arno_iris_connection():
 
 @pytest.fixture(scope="function")
 def iris_master_cleanup(iris_connection):
-    cursor = iris_connection.cursor()
+    # Some tests call native iris.createIRIS()/classMethodValue() directly on
+    # the shared session iris_connection (e.g. Arno-native e2e tests) instead
+    # of a scoped-off connection. A native-API failure there can permanently
+    # corrupt the driver's protocol/parameter-binding state for that
+    # connection (documented below re: DDL-after-createIRIS). Once that
+    # happens, iris_connection.cursor() raises <COMMUNICATION LINK ERROR> for
+    # EVERY subsequent test that requests this fixture — turning one test's
+    # native-API misuse into a suite-wide cascade. Skip cleanup gracefully
+    # instead of propagating that as a fixture-setup error.
+    try:
+        cursor = iris_connection.cursor()
+    except Exception as e:
+        pytest.skip(f"iris_connection unusable (likely corrupted by a prior "
+                     f"test's native API call) — skipping cleanup: {e}")
     try:
         for table in [
             "Graph_KG.rdf_edges",

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/e2e/test_arno_bfs_global.py

@@ -96,9 +96,12 @@ class TestArnoBFSGlobal:
 
     def test_sc004_fallback_on_no_arno(self, arno_setup):
         conn, o, eng, seed = arno_setup
-        with open("iris_src/src/Graph/KG/NKGAccel.cls") as f:
+        # BFSJson's no-arno fallback lives in NKGAccelTraversal.cls (spec 187
+        # split NKGAccel.cls into sibling classes); it calls the OS BFS
+        # fallback defined in Traversal.cls/TraversalBFS.cls.
+        with open("iris_src/src/Graph/KG/NKGAccelTraversal.cls") as f:
             cls_src = f.read()
-        assert "BFSFastJsonSorted" in cls_src, "Fallback must exist in NKGAccel.cls"
+        assert "BFSFastJsonSorted" in cls_src, "Fallback must exist in NKGAccelTraversal.cls"
 
     def test_sc005_execute_cypher_routes_through_arno(self, arno_setup):
         conn, o, eng, seed = arno_setup

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/e2e/test_betweenness_neighborhood_e2e.py

@@ -1,7 +1,10 @@
 """Spec 173 e2e tests — BetweennessNeighborhood."""
+import os
 import pytest
 import networkx as nx
 
+ARNO_LIB = os.environ.get("ARNO_LIB", "/usr/irissys/mgr/libarno_callout.so")
+
 
 @pytest.fixture(scope="module")
 def karate_engine(iris_connection):
@@ -14,7 +17,7 @@ def karate_engine(iris_connection):
     engine = IRISGraphEngine(conn)
     iris_obj = _iris.createIRIS(conn)
     iris_obj.classMethodVoid("Graph.KG.NKGAccel", "Unload")
-    iris_obj.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+    iris_obj.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
     iris_obj.classMethodValue("%SYSTEM.OBJ", "Compile", "Graph.KG.Traversal", "cuk-d")
     iris_obj.classMethodValue("%SYSTEM.OBJ", "Compile", "Graph.KG.Edge", "cuk-d")
     iris_obj.classMethodValue("%SYSTEM.OBJ", "Compile", "Graph.KG.EdgeScan", "cuk-d")

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/e2e/test_index_protocol.py

@@ -3,10 +3,10 @@ import random
 import pytest
 from iris_vector_graph.engine import IRISGraphEngine
 from iris_vector_graph.index_protocol import IVGIndex, IndexHandle
+from iris_vector_graph.schema import GraphSchema
 
 
 DIM = 16
-EMBED_DIM = 768
 
 
 @pytest.fixture(scope="module")
@@ -15,8 +15,19 @@ def engine(iris_connection):
 
 
 @pytest.fixture(scope="module")
-def engine_with_embeddings(iris_connection):
-    eng = IRISGraphEngine(iris_connection, embedding_dimension=EMBED_DIM)
+def embed_dim(iris_connection):
+    """The live container's actual kg_NodeEmbeddings dimension (ivg's own
+    detection primitive) — hardcoding a dimension here collides with whatever
+    the shared table was really initialized at and poisons the connection for
+    every other test sharing this fixture. Falls back to 768 (schema.py's own
+    default) if the table doesn't exist yet."""
+    cursor = iris_connection.cursor()
+    return GraphSchema.get_embedding_dimension(cursor) or 768
+
+
+@pytest.fixture(scope="module")
+def engine_with_embeddings(iris_connection, embed_dim):
+    eng = IRISGraphEngine(iris_connection, embedding_dimension=embed_dim)
     return eng
 
 
@@ -61,7 +72,7 @@ def hnsw_data(engine_with_embeddings):
             cur.execute("INSERT INTO Graph_KG.nodes (node_id) VALUES (?)", [nid])
     eng.conn.commit()
     for nid in nodes:
-        vec = [rng.gauss(0, 1) for _ in range(EMBED_DIM)]
+        vec = [rng.gauss(0, 1) for _ in range(eng.embedding_dimension)]
         eng.store_embedding(nid, vec)
     if not eng._probe_native_vec():
         pytest.skip("Native HNSW (kg_KNN_VEC) not available on this IRIS tier")
@@ -80,7 +91,10 @@ class TestEngineIndex:
         query = [rng.gauss(0, 1) for _ in range(DIM)]
         handle = engine.index("idx_proto_ivf")
         assert isinstance(handle, IndexHandle)
-        assert handle.type == "ivf"
+        # engine.index().type returns the unified concept name, not the legacy
+        # backend label — "ivf" maps to "vector" (Index Protocol Unification,
+        # spec 149 / _LEGACY_TO_CONCEPT in engine.py).
+        assert handle.type == "vector"
         via_handle = handle.search(query, k=3)
         via_direct = engine.ivf_search("idx_proto_ivf", query, k=3)
         assert via_handle == via_direct
@@ -88,7 +102,7 @@ class TestEngineIndex:
     def test_engine_index_bm25_dispatch(self, engine, bm25_index):
         handle = engine.index("idx_proto_bm25")
         assert isinstance(handle, IndexHandle)
-        assert handle.type == "bm25"
+        assert handle.type == "fulltext"
         via_handle = handle.search("graph", k=2)
         via_direct = engine.bm25_search("idx_proto_bm25", "graph", k=2)
         assert via_handle == via_direct
@@ -98,10 +112,11 @@ class TestEngineIndex:
         if "idx_proto_ivf" not in new_engine._index_registry:
             pytest.skip("gref $Order probe not supported on this IRIS build — registry rebuild skipped")
         handle = new_engine.index("idx_proto_ivf")
-        assert handle.type == "ivf"
+        assert handle.type == "vector"
 
     def test_engine_index_raises_for_unknown_name(self, engine):
-        with pytest.raises(ValueError, match="not found"):
+        from iris_vector_graph.errors import IndexNotFoundError
+        with pytest.raises(IndexNotFoundError, match="not found"):
             engine.index("this_index_definitely_does_not_exist_xyz")
 
     def test_engine_index_returns_ivgindex(self, engine, ivf_index):
@@ -109,6 +124,8 @@ class TestEngineIndex:
         assert isinstance(handle, IVGIndex)
 
     def test_engine_index_info_has_type(self, engine, ivf_index):
+        # info() returns the raw backend dict (legacy label "ivf"), unlike
+        # handle.type which returns the unified concept ("vector").
         info = engine.index("idx_proto_ivf").info()
         assert info.get("type") == "ivf"
 
@@ -144,7 +161,7 @@ class TestEngineIndexHNSW:
         eng = engine_with_embeddings
         rng = random.Random(99)
         new_id = "hnsw_e2e_new"
-        vec = [rng.gauss(0, 1) for _ in range(EMBED_DIM)]
+        vec = [rng.gauss(0, 1) for _ in range(eng.embedding_dimension)]
         cur = eng.conn.cursor()
         cur.execute("SELECT COUNT(*) FROM Graph_KG.nodes WHERE node_id=?", [new_id])
         if cur.fetchone()[0] == 0:
@@ -160,7 +177,7 @@ class TestEngineIndexHNSW:
     def test_hnsw_search_returns_results(self, engine_with_embeddings, hnsw_data):
         eng = engine_with_embeddings
         rng = random.Random(77)
-        query = [rng.gauss(0, 1) for _ in range(EMBED_DIM)]
+        query = [rng.gauss(0, 1) for _ in range(eng.embedding_dimension)]
         results = eng.index("hnsw").search(query, k=5)
         assert isinstance(results, list)
         assert len(results) > 0
@@ -169,7 +186,7 @@ class TestEngineIndexHNSW:
     def test_hnsw_search_matches_search_nodes_by_vector(self, engine_with_embeddings, hnsw_data):
         eng = engine_with_embeddings
         rng = random.Random(88)
-        query = [rng.gauss(0, 1) for _ in range(EMBED_DIM)]
+        query = [rng.gauss(0, 1) for _ in range(eng.embedding_dimension)]
         via_handle = eng.index("hnsw").search(query, k=5)
         via_direct = eng.search_nodes_by_vector(query, k=5)
         assert len(via_handle) == len(via_direct)

{iris_vector_graph-2.4.2 → iris_vector_graph-2.4.5}/tests/e2e/test_large_output_chunked.py

@@ -11,6 +11,7 @@ IRIS_USER = os.environ.get("IRIS_USERNAME", "_SYSTEM")
 IRIS_PASS = os.environ.get("IRIS_PASSWORD", "SYS")
 
 SKIP_LARGE_OUT = os.environ.get("SKIP_ARNO_TESTS", "false").lower() == "true"
+ARNO_LIB = os.environ.get("ARNO_LIB", "/usr/irissys/mgr/libarno_callout.so")
 skip_reason = "SKIP_ARNO_TESTS=true or enterprise container unavailable"
 
 
@@ -48,7 +49,7 @@ def kill_arno_cache(o):
     except Exception:
         pass
     try:
-        o.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+        o.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
     except Exception:
         pass
 
@@ -66,7 +67,7 @@ class TestLargeOutputChunked:
         seed = graph_seed
         o.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
         try:
-            o.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+            o.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
         except Exception:
             pass
         try:
@@ -149,7 +150,7 @@ class TestLargeOutputChunked:
 
             o1.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
             try:
-                o1.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+                o1.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
             except Exception:
                 pass
             raw1 = str(o1.classMethodValue("Graph.KG.NKGAccel", "BFSJson", seed, "[]", 3, 0))
@@ -172,7 +173,7 @@ class TestLargeOutputChunked:
         seed = graph_seed
         o.classMethodVoid("Graph.KG.NKGAccel", "ResetCache")
         try:
-            o.classMethodValue("Graph.KG.NKGAccel", "Load", "/usr/irissys/mgr/libarno_callout.so")
+            o.classMethodValue("Graph.KG.NKGAccel", "Load", ARNO_LIB)
         except Exception:
             pass
         try: