rag-wright 0.14.0__tar.gz → 0.14.1__tar.gz

rag_wright-0.14.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.14.1"
+}

{rag_wright-0.14.0 → rag_wright-0.14.1}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to RAG_Wright are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project aims to follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.14.1](https://github.com/fzaidi-dai/RAG_Wright/compare/0.14.0...0.14.1) (2026-10-28)
+
+
+### Bug Fixes
+
+* **PS-49:** a retried ArcadeDB write conflict no longer prints as an error ([32f649f](https://github.com/fzaidi-dai/RAG_Wright/commit/32f649f94ac1b864ee5b22460d3ef401dabbbf6a))
+* **PS-50:** ensure_pack_schema declares a property a pack gains on an existing type ([c27cf40](https://github.com/fzaidi-dai/RAG_Wright/commit/c27cf40dba2512f809ba1ff06affc58d7f25f45f))
+
 ## [0.14.0](https://github.com/fzaidi-dai/RAG_Wright/compare/0.13.0...0.14.0) (2026-10-17)
 
 

{rag_wright-0.14.0 → rag_wright-0.14.1}/CLAUDE.md

@@ -55,11 +55,11 @@ The failure mode to avoid, which has happened before: a command fails with "modu
 
 ## Start of every session
 
-> **CURRENT STATE (2026-10-17): the LangGraph ingestion workstream is COMPLETE, unreleased** (LGI-1..5,
+> **CURRENT STATE (2026-10-17): the LangGraph ingestion workstream is RELEASED as `rag-wright` 0.14.0** (PR #16; LGI-1..5,
 > `docs/specs/langgraph-ingestion/plan.md`, ADR-0124 amended): `build_ingestion` is a LangGraph graph
 > (`IngestionPipeline.graph`, per-document `document_graph`), `aingest(..., checkpointer=, run_id=)` resumes an
 > interrupted run (built-in state, strict msgpack safe), `IngestionReport.from_dict`; live old-vs-new parity identical;
-> guide `rulewright-migration-0.14.0.md` (next release 0.14.0). Next: PS-48 (harness tests onto the fabric fixture,
+> guide `rulewright-migration-0.14.0.md`. Next: PS-48 (harness tests onto the fabric fixture,
 > proposed, not started), EV-7, PS-30, PS-33. Before it,
 > **(2026-10-15): `rag-wright` 0.13.0 is RELEASED** (PR #15): PS-35 `migrate_span_fields` on the API,
 > PS-44 `Range` KG filters (TexWright ER-1), PS-45 `span_search` (G24), PS-46 blank PDF pages never sent to the VLM

{rag_wright-0.14.0 → rag_wright-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rag-wright
-Version: 0.14.0
+Version: 0.14.1
 Summary: A domain-retargetable, open-core engine for hybrid retrieval + knowledge-graph RAG: parsing, chunking, embedding, hybrid search, reranking, graph extraction, entity resolution, ontology-driven knowledge, and a capability runtime.
 Project-URL: Homepage, https://github.com/fzaidi-dai/RAG_Wright
 Project-URL: Repository, https://github.com/fzaidi-dai/RAG_Wright

{rag_wright-0.14.0 → rag_wright-0.14.1}/docs/domain-adaptation/ontology-authoring.md

@@ -18,7 +18,12 @@ The store creates the vertex and edge types your pack declares. The generic read
 `rag_wright.ontology.pack_schema.load_kg_schema(path)`, called by the store's `ensure_pack_schema(ttl)`, which
 `ensure_schema()` calls only when a pack is configured (`EngineConfig.pack`). It creates the `eng:KgVertexType`
 vertex types with their properties and unique indexes, and the `eng:KgStructuralEdge` edge types; nothing else in
-the pack is read by the engine. A minimal, domain-neutral example:
+the pack is read by the engine. Each is created when absent, so a pack that later gains a property gets it declared
+on the existing database the next time a process opens the workspace (`open_workspace` runs `ensure_schema`); no
+fresh database is needed. Nothing is altered or dropped: a property whose declared type changed is logged as a
+warning and left as it is (a migration is yours to run), and a numeric property declared over values stored before it
+is logged too, since those values are not converted until a re-ingest rewrites them (a value that does not
+convert, `'195 GSM'` for a `DOUBLE`, fails its write and dead-letters that document). A minimal, domain-neutral example:
 
 ```turtle
 @prefix eng:  <https://ragwright.local/ontology/engine#> .

{rag_wright-0.14.0 → rag_wright-0.14.1}/docs/specs/public-surface/plan.md

@@ -120,3 +120,5 @@ in two at the PS-6 gate so the store rewrite is its own visible task. One task,
 | PS-45 | Engine gap G24: a public hybrid span search. `span_search(ws, query, *, k, documents, tag, dense_floor)` and `aspan_search` on `rag_wright.api`, over the span index ingestion fills: the store-side RRF fusion of the dense and sparse legs plus the dense floor (ADR-0104), returning citation-ready `SpanHit`s (text, document, offsets, pages, box, `found_by`); no reranking (the caller composes `BGEReranker`). G24 closed; the guide, the authoring page and the specifying and consumer skills name it | hermetic tests of the composition and the public call; a live test on real ArcadeDB and BGE-M3 (found by meaning, scoped, cited) | done 2026-10-15 |
 | PS-46 | TexWright's 2026-10-15 report: a blank page escalated to the VLM came back as an invented document the parse kept. The scan-quality gate gains `ScanQuality.BLANK` (no OCR text and no ink: `ink_frac`, pixels < 200, at most 1e-4; the heavy faint scan measures ~0.08) and `TieredOCRParser` never escalates or flags a blank page, reporting it in `TieredOCRReport.blank_pages`. The post-check stays a flag, not a filter (a verbatim transcription of a page with few common English words fails it). ADR-0062 amended | hermetic gate and tiered tests (a real 2-page PDF: the VLM gets page 1 only); a live docling parse reports the blank page; the heavy fixture still escalates all 10 pages | done 2026-10-15 |
 | PS-47 | The audit for PS-46: a parse cached before the fix keeps a blank page's invented text (the cache is keyed on content). `find_blank_pages_with_text(cache_dir, sources=(), *, progress)` and `BlankPageText` on `rag_wright.api` list every page blank in the source PDF (no ink, no text layer) with text in its cached parse, and the cache files to delete before re-ingesting. Searches the cache recursively (`aingest` keeps parses in `parsed/`); embedded files are audited from the cache's own copies; top-level sources are passed as paths or `(name, bytes)` | hermetic tests; a live `build_ingestion` of a workbook embedding a blank-tail PDF: clean, then a planted page found with nothing passed, then clean after delete and re-ingest | done 2026-10-15 |
+| PS-49 | TexWright's request (`docs/engine-requests/2026-10-17-concurrent-modification-printed-during-a-clean-ingest.md`, their repo): a clean keeper ingest printed `ArcadeDB Error Response ... ConcurrentModificationException` lines that read as failures. The retry is the engine's (`_retry_on_conflict`, every store write, since ING-5); the line is the client library's own ERROR log, printed before it raises. A log filter drops that line while the retry handles the call; the retry logs INFO `retried N times; the write landed`, or ERROR `gave up after 10 attempts` and raises | three hermetic tests (red before, green after); live 8-thread concurrent writes: 240/240 landed, 130 error lines before the fix, 0 after (62 INFO retried lines) | done 2026-10-17 |
+| PS-50 | TexWright's request (`docs/engine-requests/2026-10-28-ensure_pack_schema-does-not-declare-a-new-property-on-an-existing-type.md`, their repo): `ensure_pack_schema` declared a type's properties only when it created the type. It now creates every declared property the type lacks, on existing types too; a property whose declared type differs is logged and left as it is; a property the pack dropped stays; a non-STRING property declared over values stored before it is logged (they are not converted; a re-ingest rewrites them, and a value that does not convert fails its write) | a live test (red before, green after: added, mismatch reported, nothing dropped, the unconverted-values warning, a second run issues no DDL); live probe of a re-ingest over the new DOUBLE | done 2026-10-28 |

{rag_wright-0.14.0 → rag_wright-0.14.1}/docs/specs/public-surface/rulewright-migration-0.14.0.md

@@ -1,6 +1,6 @@
 # RuleWright: moving to rag-wright 0.14
 
-What 0.14.0 changes for RuleWright (the LangGraph ingestion workstream, `docs/specs/langgraph-ingestion/plan.md`,
+What 0.14.0 changes for RuleWright (released 2026-10-17: PyPI and GitHub release `0.14.0`, PR #16; the LangGraph ingestion workstream, `docs/specs/langgraph-ingestion/plan.md`,
 LGI-1 to LGI-5; ADR-0124 amended). Do the 0.13 guide first. Nothing here is edited from the engine repo, and nothing
 breaks an existing call.
 

{rag_wright-0.14.0 → rag_wright-0.14.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rag-wright"
-version = "0.14.0"
+version = "0.14.1"
 description = "A domain-retargetable, open-core engine for hybrid retrieval + knowledge-graph RAG: parsing, chunking, embedding, hybrid search, reranking, graph extraction, entity resolution, ontology-driven knowledge, and a capability runtime."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{rag_wright-0.14.0 → rag_wright-0.14.1}/src/rag_wright/store/arcadedb.py

@@ -16,6 +16,7 @@ introspection: create only what is absent.
 
 from __future__ import annotations
 
+import contextvars
 import json
 import logging
 import os
@@ -69,6 +70,18 @@ _SPAN_SPARSE_INDEX = f"{SPAN_TYPE}[sparse_indices,sparse_weights]"
 # retry; the failed command or transaction is rolled back whole, so a bounded retry with jittered backoff is safe
 # (found by the ING-5 doc audit: unretried, concurrent ingestion silently lost spans and records).
 _CONFLICT_RETRIES = 10
+# PS-49 (TexWright, 2026-10-17): the client logs every error response at ERROR before raising, so a conflict the retry
+# absorbs printed exactly like a failure. While a retry is handling the call, that line is dropped; the retry says
+# itself what happened (INFO when the write landed after retrying, ERROR when it gave up).
+_RETRYING = contextvars.ContextVar("arcadedb_retrying", default=False)
+
+
+class _RetriedConflictFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        return not (_RETRYING.get() and _is_retryable_conflict(Exception(record.getMessage())))
+
+
+logging.getLogger("arcadedb_python.api.sync").addFilter(_RetriedConflictFilter())
 
 
 def _is_retryable_conflict(exc: BaseException) -> bool:
@@ -77,13 +90,24 @@ def _is_retryable_conflict(exc: BaseException) -> bool:
 
 
 def _retry_on_conflict(fn, *args, **kwargs):
-    for attempt in range(_CONFLICT_RETRIES):
-        try:
-            return fn(*args, **kwargs)
-        except Exception as exc:  # noqa: BLE001 - only the retryable conflict is retried; anything else re-raises
-            if attempt == _CONFLICT_RETRIES - 1 or not _is_retryable_conflict(exc):
-                raise
-            time.sleep(min(0.5, 0.01 * 2 ** attempt) + random.uniform(0, 0.01))
+    token = _RETRYING.set(True)
+    try:
+        for attempt in range(_CONFLICT_RETRIES):
+            try:
+                result = fn(*args, **kwargs)
+            except Exception as exc:  # noqa: BLE001 - only the retryable conflict is retried; anything else re-raises
+                if not _is_retryable_conflict(exc):
+                    raise
+                if attempt == _CONFLICT_RETRIES - 1:
+                    _log.error("ArcadeDB write conflict: gave up after %d attempts: %s", _CONFLICT_RETRIES, exc)
+                    raise
+                time.sleep(min(0.5, 0.01 * 2 ** attempt) + random.uniform(0, 0.01))
+            else:
+                if attempt:
+                    _log.info("ArcadeDB write conflict retried %d times; the write landed", attempt)
+                return result
+    finally:
+        _RETRYING.reset(token)
 
 
 def _sql_str(value: str) -> str:
@@ -391,18 +415,33 @@ class ArcadeDBStore:
 
     def ensure_pack_schema(self, pack_ttl: str) -> None:
         """ING-8a/8b (ADR-0067 P5b): create a domain PACK's declared schema from its own `.ttl`, idempotently -- the
-        vertex types + their unique id indexes and the structural edges (`ontology.pack_schema.load_kg_schema`).
-        Called by `ensure_schema` for a configured pack, and by a pack on use (the reference contract pack does,
-        then adds its own typed property edges via `ensure_edge_types`)."""
+        vertex types, their declared properties, their unique id indexes and the structural edges
+        (`ontology.pack_schema.load_kg_schema`); each is created when absent, so a pack that gains a type, a property,
+        an index or an edge gets it on a database that already exists (PS-50). Nothing is altered or dropped: a
+        property whose declared type differs from the pack's is logged as a warning and left as it is, a property the
+        pack no longer declares stays, and a non-STRING property declared over values stored before it is logged
+        (those values are not converted; a re-ingest rewrites them, and fails the write of one that does not convert). Called by `ensure_schema` for a configured pack,
+        and by a pack on use (the reference contract pack does, then adds its own typed property edges via
+        `ensure_edge_types`)."""
         vertex_types, structural_edges = load_kg_schema(pack_ttl)
         self._ensured_packs = [*getattr(self, "_ensured_packs", []), pack_ttl]
         self._prop_types_cache = None  # re-derive the property encodings with this pack included
         types = self.type_names()
         for vt in vertex_types:
+            existing: dict[str, str] = {}
             if vt.name not in types:
                 self._command(f"CREATE VERTEX TYPE {vt.name}")
-                for pname, ptype in vt.properties:
+            else:
+                existing = self._declared_property_types(vt.name)
+            for pname, ptype in vt.properties:
+                if pname not in existing:
                     self._command(f"CREATE PROPERTY {vt.name}.{pname} {ptype}")
+                    if vt.name in types and ptype != "STRING":
+                        self._warn_unconverted_values(vt.name, pname, ptype)
+                elif existing[pname] != ptype:
+                    _log.warning("%s.%s is declared %s in the database but %s by the pack %s; left as it is (changing "
+                                 "a declared type over stored values is a data migration)",
+                                 vt.name, pname, existing[pname], ptype, pack_ttl)
         self.ensure_edge_types(sorted(structural_edges), types=types)
         indexes = self.index_names()
         for vt in vertex_types:
@@ -412,6 +451,19 @@ class ArcadeDBStore:
     def type_names(self) -> set[str]:
         return {row["name"] for row in self._query("SELECT name FROM schema:types")}
 
+    def _declared_property_types(self, type_name: str) -> dict[str, str]:
+        for row in self._query("SELECT name, properties FROM schema:types"):
+            if row.get("name") == type_name:
+                return {prop["name"]: prop.get("type") for prop in row.get("properties", [])}
+        return {}
+
+    def _warn_unconverted_values(self, type_name: str, pname: str, ptype: str) -> None:
+        n = self._query(f"SELECT count(*) AS n FROM {type_name} WHERE {pname} IS NOT NULL")[0]["n"]
+        if n:
+            _log.warning("%s.%s is now declared %s; %d existing record(s) already held a value, which is not "
+                         "converted (a re-ingest rewrites them as %s; a value that is not one fails its write)",
+                         type_name, pname, ptype, n, ptype)
+
     def property_names(self, type_name: str) -> set[str]:
         for row in self._query("SELECT name, properties FROM schema:types"):
             if row.get("name") == type_name:

{rag_wright-0.14.0 → rag_wright-0.14.1}/tasks.md

@@ -3,9 +3,11 @@
 Phase 2 output. The persistent, cross-session task ledger and shared memory of progress. Derived
 from `plan.md` (Phase 1) and `SPEC.md` v0.1, honoring ADR-0001 (stack) and ADR-0002 (corpus).
 
-> **⇒ RESUME / NEXT UP (2026-10-17, NEWEST): the LangGraph ingestion workstream is COMPLETE, unreleased**
+> **⇒ RESUME / NEXT UP (2026-10-17, NEWEST): the LangGraph ingestion workstream is RELEASED as `rag-wright` 0.14.0** (PR #16)
 > (`docs/specs/langgraph-ingestion/plan.md`, LGI-1..5; ADR-0124 amended; RuleWright guide
-> `docs/specs/public-surface/rulewright-migration-0.14.0.md`). Next: PS-48 (harness behaviour tests onto the fabric
+> `docs/specs/public-surface/rulewright-migration-0.14.0.md`). PS-49 done 2026-10-17 (a retried ArcadeDB write conflict no
+> longer prints as an error; TexWright's request) and PS-50 done 2026-10-28 (`ensure_pack_schema` declares a property a pack gains on an
+> existing type; TexWright's request); both unreleased, land as 0.14.1. Next: PS-48 (harness behaviour tests onto the fabric
 > fixture; proposed with sub-tasks PS-48a..g, awaiting go-ahead), EV-7, PS-30, PS-33. Before it,
 > **(2026-10-14): PS-32 done, the agent harness is `rag_wright.harness`** (third public
 > tier, ADR-0139; with PS-39); RELEASED as `rag-wright` 0.10.0 (PyPI + GitHub release, PR #12); RuleWright's guide `docs/specs/public-surface/rulewright-migration-0.10.0.md`.

rag_wright-0.14.1/tests/store/test_concurrent_writes.py

@@ -0,0 +1,108 @@
+"""ING-5 (found by the doc audit's live run): ArcadeDB answers concurrent writes to the same bucket with a
+`ConcurrentModificationException` ("Please retry the operation"); the store must retry them, or concurrent ingestion
+(`IngestionTuning.document_concurrency`, default 2) silently loses spans and records. A failed command or transaction
+is rolled back whole, so the retry is safe."""
+from __future__ import annotations
+
+import concurrent.futures as cf
+
+import pytest
+
+from rag_wright.contracts.chunk import BGE_M3_DENSE_DIM
+from rag_wright.contracts.span import SpanRecord
+from rag_wright.store.arcadedb import ArcadeDBStore, _is_retryable_conflict
+from rag_wright.store.seam import KgNode
+
+_DB = "ragwright_test_concurrent_writes"
+
+
+def test_only_a_concurrent_modification_is_retried():
+    assert _is_retryable_conflict(Exception(
+        "Cannot execute command: Concurrent modification on page PageId(db/9/0) in file 'Span_0.9.65536.v0.bucket' "
+        "(current v.1 <> database v.2). Please retry the operation (threadId=1)"))
+    assert not _is_retryable_conflict(Exception("Type with name 'Clause' was not found"))
+
+
+@pytest.mark.store
+def test_concurrent_span_and_record_writes_all_land():
+    s = ArcadeDBStore.from_env(database=_DB, reset=True)
+    try:
+        s.ensure_schema()
+        s._command("CREATE VERTEX TYPE Rec")
+        s._command("CREATE PROPERTY Rec.k STRING")
+        s._command("CREATE INDEX ON Rec (k) UNIQUE")
+
+        def span(i):
+            s.upsert_span(SpanRecord(span_id=f"d{i % 2}:0:h#{i}", parent_chunk_id=f"d{i % 2}:0:h", span_index=i,
+                                     text=f"t{i}", dense_vector=[0.01] * BGE_M3_DENSE_DIM, sparse_vector={i: 1.0},
+                                     document_id=f"d{i % 2}"))
+
+        def rec(i):
+            s.kg_write([KgNode("Rec", "k", {"k": f"r{i}"})])
+
+        with cf.ThreadPoolExecutor(8) as ex:
+            list(ex.map(span, range(120)))
+            list(ex.map(rec, range(120)))
+        assert s._query("SELECT count(*) AS n FROM Span")[0]["n"] == 120
+        assert s._query("SELECT count(*) AS n FROM Rec")[0]["n"] == 120
+    finally:
+        s.drop()
+        s.close()
+
+
+_CONFLICT = ("Cannot execute command: Concurrent modification on page PageId(db/9/680) in file 'Span_0.9.65536.v0.bucket' "
+             "(current v.113 <> database v.114). Please retry the operation (threadId=65)")
+
+
+def _flaky(failures: int):
+    """A write that fails like the ArcadeDB client does: it logs the error response, then raises."""
+    import logging
+
+    client_log = logging.getLogger("arcadedb_python.api.sync")
+    calls = []
+
+    def write():
+        calls.append(1)
+        if len(calls) <= failures:
+            client_log.error("ArcadeDB Error Response: {'detail': %r, 'exception': "
+                             "'com.arcadedb.exception.ConcurrentModificationException'}", _CONFLICT)
+            raise Exception(_CONFLICT)
+        return "ok"
+    return write, calls
+
+
+def test_a_retried_conflict_prints_no_error_and_says_it_was_retried(caplog, monkeypatch):
+    # PS-49 (TexWright's 2026-10-17 request): a conflict the retry absorbs must not read like a failure.
+    from rag_wright.store import arcadedb
+
+    monkeypatch.setattr(arcadedb.time, "sleep", lambda _s: None)
+    write, calls = _flaky(failures=2)
+    with caplog.at_level("INFO"):
+        assert arcadedb._retry_on_conflict(write) == "ok"
+    assert len(calls) == 3
+    assert not [r for r in caplog.records if r.levelname == "ERROR"]
+    retried = [r.getMessage() for r in caplog.records if r.name == arcadedb.__name__]
+    assert len(retried) == 1 and "retried 2 times" in retried[0] and "landed" in retried[0]
+
+
+def test_a_conflict_that_outlasts_the_retries_is_raised_and_logged(caplog, monkeypatch):
+    from rag_wright.store import arcadedb
+
+    monkeypatch.setattr(arcadedb.time, "sleep", lambda _s: None)
+    write, calls = _flaky(failures=arcadedb._CONFLICT_RETRIES)
+    with caplog.at_level("INFO"), pytest.raises(Exception, match="Concurrent modification"):
+        arcadedb._retry_on_conflict(write)
+    assert len(calls) == arcadedb._CONFLICT_RETRIES
+    errors = [r for r in caplog.records if r.levelname == "ERROR"]
+    assert len(errors) == 1 and errors[0].name == arcadedb.__name__ and "gave up" in errors[0].getMessage()
+
+
+def test_an_error_outside_a_retry_still_prints():
+    # The filter hides only conflicts the retry is handling; any other client error response still reaches the log.
+    import logging
+
+    from rag_wright.store import arcadedb  # noqa: F401 - installs the filter
+
+    record = logging.LogRecord("arcadedb_python.api.sync", logging.ERROR, __file__, 0,
+                               "ArcadeDB Error Response: %s", (_CONFLICT,), None)
+    assert all(f.filter(record) for f in logging.getLogger("arcadedb_python.api.sync").filters)

rag_wright-0.14.1/tests/store/test_pack_schema_properties.py

@@ -0,0 +1,54 @@
+"""PS-50 (TexWright's 2026-10-28 request): `ensure_pack_schema` reconciles PROPERTIES the way it reconciles types,
+edge types and unique indexes: a property a pack gains is declared on a type the database already holds. A property
+whose declared type moved is reported, never altered; a property the pack stopped declaring is never dropped."""
+from __future__ import annotations
+
+import pytest
+
+from rag_wright.store.arcadedb import ArcadeDBStore
+
+_DB = "ragwright_test_pack_schema_properties"
+
+
+def _pack(tmp_path, name, *props):
+    path = tmp_path / f"{name}.ttl"
+    declared = ", ".join(f'"{p}"' for p in props)
+    path.write_text("@prefix eng: <https://ragwright.local/ontology/engine#> .\n"
+                    "@prefix t: <https://example.test/t#> .\n"
+                    f't:RecNode a eng:KgVertexType ; eng:vertexName "Rec" ; eng:kgProperty {declared} ;\n'
+                    '    eng:uniqueIndexOn "rec_id" .\n')
+    return str(path)
+
+
+def _declared(store, type_name):
+    return {p["name"]: p["type"] for r in store._query("SELECT name, properties FROM schema:types")
+            if r["name"] == type_name for p in r.get("properties", [])}
+
+
+@pytest.mark.store
+def test_a_property_a_pack_gains_is_declared_on_an_existing_type(tmp_path, caplog):
+    s = ArcadeDBStore.from_env(database=_DB, reset=True)
+    try:
+        s.ensure_pack_schema(_pack(tmp_path, "v1", "rec_id:STRING", "name:STRING", "dropped:STRING"))
+        s._command("INSERT INTO Rec SET rec_id = 'r1', name = 'a', weight = '195 GSM'")  # a re-ingest stored it early
+
+        v2 = _pack(tmp_path, "v2", "rec_id:STRING", "name:INTEGER", "label:STRING", "weight:DOUBLE")
+        with caplog.at_level("WARNING", logger="rag_wright.store.arcadedb"):
+            s.ensure_pack_schema(v2)
+        assert _declared(s, "Rec") == {"rec_id": "STRING", "name": "STRING", "dropped": "STRING",
+                                       "label": "STRING", "weight": "DOUBLE"}  # added; never retyped or dropped
+        warned = " ".join(r.getMessage() for r in caplog.records)
+        assert "Rec.name" in warned and "STRING" in warned and "INTEGER" in warned  # the moved type is reported
+        assert "Rec.weight" in warned and "1 existing" in warned  # values stored before the declaration: unconverted
+        assert "Rec.label" not in warned  # a new STRING over no values needs no word
+
+        caplog.clear()
+        cmds = []
+        run = s._command
+        s._command = lambda sql: (cmds.append(sql), run(sql))[1]
+        with caplog.at_level("WARNING", logger="rag_wright.store.arcadedb"):
+            s.ensure_pack_schema(v2)
+        assert cmds == []  # idempotent: nothing left to declare
+    finally:
+        s.drop()
+        s.close()

{rag_wright-0.14.0 → rag_wright-0.14.1}/uv.lock

@@ -3534,7 +3534,7 @@ wheels = [
 
 [[package]]
 name = "rag-wright"
-version = "0.14.0"
+version = "0.14.1"
 source = { editable = "." }
 dependencies = [
     { name = "arcadedb-python" },

rag_wright-0.14.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.14.0"
-}

rag_wright-0.14.0/tests/store/test_concurrent_writes.py

@@ -1,50 +0,0 @@
-"""ING-5 (found by the doc audit's live run): ArcadeDB answers concurrent writes to the same bucket with a
-`ConcurrentModificationException` ("Please retry the operation"); the store must retry them, or concurrent ingestion
-(`IngestionTuning.document_concurrency`, default 2) silently loses spans and records. A failed command or transaction
-is rolled back whole, so the retry is safe."""
-from __future__ import annotations
-
-import concurrent.futures as cf
-
-import pytest
-
-from rag_wright.contracts.chunk import BGE_M3_DENSE_DIM
-from rag_wright.contracts.span import SpanRecord
-from rag_wright.store.arcadedb import ArcadeDBStore, _is_retryable_conflict
-from rag_wright.store.seam import KgNode
-
-_DB = "ragwright_test_concurrent_writes"
-
-
-def test_only_a_concurrent_modification_is_retried():
-    assert _is_retryable_conflict(Exception(
-        "Cannot execute command: Concurrent modification on page PageId(db/9/0) in file 'Span_0.9.65536.v0.bucket' "
-        "(current v.1 <> database v.2). Please retry the operation (threadId=1)"))
-    assert not _is_retryable_conflict(Exception("Type with name 'Clause' was not found"))
-
-
-@pytest.mark.store
-def test_concurrent_span_and_record_writes_all_land():
-    s = ArcadeDBStore.from_env(database=_DB, reset=True)
-    try:
-        s.ensure_schema()
-        s._command("CREATE VERTEX TYPE Rec")
-        s._command("CREATE PROPERTY Rec.k STRING")
-        s._command("CREATE INDEX ON Rec (k) UNIQUE")
-
-        def span(i):
-            s.upsert_span(SpanRecord(span_id=f"d{i % 2}:0:h#{i}", parent_chunk_id=f"d{i % 2}:0:h", span_index=i,
-                                     text=f"t{i}", dense_vector=[0.01] * BGE_M3_DENSE_DIM, sparse_vector={i: 1.0},
-                                     document_id=f"d{i % 2}"))
-
-        def rec(i):
-            s.kg_write([KgNode("Rec", "k", {"k": f"r{i}"})])
-
-        with cf.ThreadPoolExecutor(8) as ex:
-            list(ex.map(span, range(120)))
-            list(ex.map(rec, range(120)))
-        assert s._query("SELECT count(*) AS n FROM Span")[0]["n"] == 120
-        assert s._query("SELECT count(*) AS n FROM Rec")[0]["n"] == 120
-    finally:
-        s.drop()
-        s.close()