knowledge-graph-rdbms 0.1.2__tar.gz → 0.1.3__tar.gz

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: knowledge-graph-rdbms
-Version: 0.1.2
+Version: 0.1.3
 Summary: A label property graph on an RDBMS (SQLite): nodes, typed edges, an append-only event log, and an optional MCP server.
 Project-URL: Homepage, https://github.com/cunicopia-dev/knowledge-graph-rdbms
 Project-URL: Repository, https://github.com/cunicopia-dev/knowledge-graph-rdbms
@@ -34,7 +34,7 @@ Description-Content-Type: text/markdown
 ![Python](https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green)
 ![core dependencies: 0](https://img.shields.io/badge/core_dependencies-0-success)
-![tests: 79 passing](https://img.shields.io/badge/tests-79_passing-brightgreen)
+![tests: 87 passing](https://img.shields.io/badge/tests-87_passing-brightgreen)
 ![storage: SQLite](https://img.shields.io/badge/storage-SQLite-003B57?logo=sqlite&logoColor=white)
 ![MCP](https://img.shields.io/badge/MCP-ready-FF6F00)
 

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/README.md

@@ -3,7 +3,7 @@
 ![Python](https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green)
 ![core dependencies: 0](https://img.shields.io/badge/core_dependencies-0-success)
-![tests: 79 passing](https://img.shields.io/badge/tests-79_passing-brightgreen)
+![tests: 87 passing](https://img.shields.io/badge/tests-87_passing-brightgreen)
 ![storage: SQLite](https://img.shields.io/badge/storage-SQLite-003B57?logo=sqlite&logoColor=white)
 ![MCP](https://img.shields.io/badge/MCP-ready-FF6F00)
 

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/kgrdbms/__init__.py

@@ -12,7 +12,7 @@ A small, dependency-free knowledge-graph core:
 
 from __future__ import annotations
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 from kgrdbms.graph import Edge, Graph, Node, default_graph_path, slug
 from kgrdbms.events import (

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/kgrdbms/cli.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import sqlite3
 import sys
 from typing import Any
 
@@ -600,6 +601,11 @@ def main(argv: list[str] | None = None) -> int:
     except (KeyError, ValueError, FileNotFoundError) as e:
         print(f"error: {e}", file=sys.stderr)
         return 1
+    except sqlite3.IntegrityError as e:
+        # Safety net for any FK/constraint path not pre-checked in service.py
+        # (e.g. restoring a deleted node whose edge endpoint is since gone).
+        print(f"error: {e}", file=sys.stderr)
+        return 1
     finally:
         app.close()
 

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/kgrdbms/events.py

@@ -53,6 +53,7 @@ OP_NODE_DEL_PROPERTY = "NODE_DEL_PROPERTY"
 OP_EDGE_ADD = "EDGE_ADD"
 OP_EDGE_REMOVE = "EDGE_REMOVE"
 OP_RESTORE = "RESTORE"        # re-create a captured node + its edges (used to undo a delete)
+OP_NODE_RESTORE_STATE = "NODE_RESTORE_STATE"  # exact-restore a node to a prior snapshot (undo of an upsert)
 OP_BATCH = "BATCH"            # add many nodes + edges in one event
 OP_GENESIS = "GENESIS"
 
@@ -226,7 +227,11 @@ class EventLog:
             prior = p.get("prior")
             if prior is None:
                 return OP_NODE_DELETE, {"node": p["after"], "edges": []}
-            return OP_NODE_UPSERT, {"after": prior, "prior": p["after"]}
+            # A plain re-upsert of `prior` would MERGE, so it cannot remove the
+            # labels/properties this upsert *added* — leaving a non-inverse. The
+            # exact-restore op carries the prior snapshot plus the `added` delta,
+            # so it can strip those additions and rebuild `prior` precisely.
+            return OP_NODE_RESTORE_STATE, {"node": prior, "added": p["after"]}
         if op == OP_NODE_DELETE:
             return OP_RESTORE, {"node": p["node"], "edges": p.get("edges", [])}
         if op == OP_NODE_SET_LABEL:
@@ -261,6 +266,19 @@ def apply_event(graph: "Graph", ev: GraphEvent) -> None:
                        labels=spec.get("labels", []), properties=spec.get("properties", {}))
         for e in p.get("edges", []):
             graph.add_edge(e["from"], e["to"], e["type"], e.get("properties", {}))
+    elif op == OP_NODE_RESTORE_STATE:
+        # Exact-restore a node to `node`, removing the labels/properties that the
+        # reverted upsert added (`added` is that upsert's delta). add_node is a
+        # merge, so we must strip the additions first, then rebuild the snapshot.
+        target = p["node"]
+        added = p.get("added", {})
+        nid = target["id"]
+        for label in set(added.get("labels", [])) - set(target.get("labels", [])):
+            graph.remove_label(nid, label)
+        for key in set(added.get("properties", {}).keys()) - set(target.get("properties", {}).keys()):
+            graph.del_property(nid, key)
+        graph.add_node(nid, target["kind"], target["name"],
+                       labels=target.get("labels", []), properties=target.get("properties", {}))
     elif op == OP_NODE_SET_LABEL:
         graph.add_label(p["id"], p["label"])
     elif op == OP_NODE_REMOVE_LABEL:

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/kgrdbms/rdf.py

@@ -29,6 +29,7 @@ import json
 import re
 from dataclasses import dataclass, field
 from typing import Any, Iterator
+from urllib.parse import quote, unquote
 
 from kgrdbms.backends.base import GraphBackend
 from kgrdbms.graph import Edge, Node
@@ -78,6 +79,22 @@ XSD = "http://www.w3.org/2001/XMLSchema#"
 KG = "https://kg.local/vocab#"
 
 
+def _enc(segment: str) -> str:
+    """Percent-encode an arbitrary string into a valid IRI path/fragment segment.
+
+    Node references are slug-safe, but `kind`, edge `type`, and property `key`
+    are free-form user text — a space or '%' there would otherwise emit an IRI
+    no conformant RDF store will parse. `safe=""` also encodes '/', so a key like
+    'a/b' can't masquerade as a path boundary. Inverted by `_dec` on import.
+    """
+    return quote(segment, safe="")
+
+
+def _dec(segment: str) -> str:
+    """Invert `_enc` — percent-decode an IRI segment back to its stored value."""
+    return unquote(segment)
+
+
 # ---- IRI context: the CURIE -> IRI expansion table -------------------
 
 
@@ -106,13 +123,13 @@ class IriContext:
             base = self.prefix_bases.get(prefix, f"{self.default_base}{prefix}/")
         else:
             prefix, ref, base = "", node_id, self.default_base
-        return Iri(f"{base}{ref}")
+        return Iri(f"{base}{_enc(ref)}")
 
     def prop_predicate(self, key: str) -> Iri:
-        return Iri(f"{self.prop_base}{key}")
+        return Iri(f"{self.prop_base}{_enc(key)}")
 
     def edge_predicate(self, edge_type: str) -> Iri:
-        return Iri(f"{self.edge_base}{edge_type}")
+        return Iri(f"{self.edge_base}{_enc(edge_type)}")
 
 
 # ---- value -> literal typing -----------------------------------------
@@ -163,7 +180,7 @@ def node_to_triples(node: Node, ctx: IriContext) -> list[Triple]:
     s = ctx.expand_node(node.id)
     triples: list[Triple] = [
         # kind -> rdf:type, pointing at a class IRI under the kg vocab.
-        (s, Iri(f"{RDF}type"), Iri(f"{KG}{node.kind}")),
+        (s, Iri(f"{RDF}type"), Iri(f"{KG}{_enc(node.kind)}")),
     ]
     if node.name:
         triples.append((s, Iri(f"{KG}name"), Literal(node.name)))
@@ -494,18 +511,19 @@ def contract_iri(iri: str, ctx: IriContext) -> str:
     # Explicit prefix bindings win (longest base first to avoid prefix overlap).
     for prefix, base in sorted(ctx.prefix_bases.items(), key=lambda kv: -len(kv[1])):
         if iri.startswith(base):
-            return f"{prefix}:{iri[len(base):]}"
+            return f"{prefix}:{_dec(iri[len(base):])}"
     if iri.startswith(ctx.default_base):
         rest = iri[len(ctx.default_base):]
         if "/" in rest:
             prefix, ref = rest.split("/", 1)
-            return f"{prefix}:{ref}"
-        return rest
+            return f"{prefix}:{_dec(ref)}"
+        return _dec(rest)
     return iri  # foreign IRI — keep verbatim
 
 
 def _local_after(iri: str, base: str) -> str | None:
-    return iri[len(base):] if iri.startswith(base) else None
+    """Strip `base` and percent-decode the remaining segment (kind/type/key)."""
+    return _dec(iri[len(base):]) if iri.startswith(base) else None
 
 
 def triples_to_graph(triples: list[Triple], ctx: IriContext | None = None) -> tuple[list[dict], list[dict]]:

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/kgrdbms/service.py

@@ -95,6 +95,11 @@ def upsert_node(
 
 def set_label(graph: Graph, events: EventLog, id: str, label: str, actor: str = "anonymous") -> Node | None:
     guard(graph, _node_ctx(graph, id, "node_set_label"))
+    node = graph.node(id)
+    if node is None:
+        raise ValueError(f"node {id!r} does not exist")
+    if label in node.labels:
+        return node  # already present: a true no-op, so don't log a non-invertible event
     graph.add_label(id, label)
     events.record(actor, OP_NODE_SET_LABEL, {"id": id, "label": label})
     return graph.node(id)
@@ -107,7 +112,9 @@ def set_property(
     ctx.property_key = key
     guard(graph, ctx)
     prior_node = graph.node(id)
-    prior_value = prior_node.properties.get(key, _MISSING) if prior_node else _MISSING
+    if prior_node is None:
+        raise ValueError(f"node {id!r} does not exist")
+    prior_value = prior_node.properties.get(key, _MISSING)
     graph.set_property(id, key, value)
     events.record(actor, OP_NODE_SET_PROPERTY, {"id": id, "key": key, "value": value, "prior": prior_value})
     return graph.node(id)
@@ -139,6 +146,9 @@ def add_edge(
 ) -> Edge:
     ctx = MutationContext(operation="edge_add", edge_type=type, from_node_id=from_id, to_node_id=to_id)
     guard(graph, ctx)
+    for endpoint, role in ((from_id, "from"), (to_id, "to")):
+        if graph.node(endpoint) is None:
+            raise ValueError(f"{role} node {endpoint!r} does not exist")
     edge = graph.add_edge(from_node=from_id, to_node=to_id, type=type, properties=properties or {})
     events.record(actor, OP_EDGE_ADD, {"edge": edge_spec(edge)})
     return edge

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "knowledge-graph-rdbms"
-version = "0.1.2"
+version = "0.1.3"
 description = "A label property graph on an RDBMS (SQLite): nodes, typed edges, an append-only event log, and an optional MCP server."
 readme = "README.md"
 requires-python = ">=3.10"

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/tests/test_cli.py

@@ -189,3 +189,25 @@ def test_rdf_export_lossy_reports_dropped(db, capsys):
     assert "rel/influences" in captured.out      # bare edge present
     assert "prop/since" not in captured.out       # property dropped
     assert "dropped" in captured.err              # but loudly, not silently
+
+
+# ---- regression: FK violations exit 1 cleanly, no traceback ---------
+
+
+def test_set_label_missing_node_exits_1(db, capsys):
+    assert run(db, "node", "add-label", "ghost:1", "L") == 1
+    err = capsys.readouterr().err
+    assert "does not exist" in err and "Traceback" not in err
+
+
+def test_set_prop_missing_node_exits_1(db, capsys):
+    assert run(db, "node", "set-prop", "ghost:1", "k", "1") == 1
+    assert "does not exist" in capsys.readouterr().err
+
+
+def test_edge_add_missing_endpoint_exits_1(db, capsys):
+    run(db, "node", "add", "x:1", "--kind", "T")
+    capsys.readouterr()
+    assert run(db, "edge", "add", "x:1", "y:1", "LINK") == 1
+    err = capsys.readouterr().err
+    assert "to node 'y:1' does not exist" in err and "Traceback" not in err

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/tests/test_events.py

@@ -154,3 +154,52 @@ def test_batch_op_is_replayable(tmp_path):
     assert g.node("n:1") is not None
     assert g.out("n:1", "LINK")
     g.close()
+
+
+# ---- regression: revert of an upsert is a TRUE inverse --------------
+
+
+def test_revert_upsert_removes_added_labels_and_props(tmp_path):
+    """An upsert that ADDS labels/props must, on revert, restore the node
+    exactly to its prior state — not merely overwrite changed values.
+    Regression for: compensation merged instead of replacing."""
+    from kgrdbms import service
+
+    g, log = _fresh(tmp_path)
+    service.upsert_node(g, log, id="t:1", kind="T", labels=["A"], properties={"color": "red"})
+    service.upsert_node(g, log, id="t:1", kind="T", labels=["B"],
+                        properties={"color": "blue", "size": "big"})
+    ev2 = log.tail(1)[0].id
+
+    service.revert_event(log, ev2)
+    n = g.node("t:1")
+    assert sorted(n.labels) == ["A"]                 # added label B removed
+    assert n.properties == {"color": "red"}          # added prop dropped, value restored
+
+
+def test_replay_after_revert_is_consistent(tmp_path):
+    """The new restore-state op must itself be replayable: rebuilding from the
+    log reproduces the post-revert state."""
+    from kgrdbms import service
+
+    g, log = _fresh(tmp_path)
+    service.upsert_node(g, log, id="t:1", kind="T", labels=["A"], properties={"color": "red"})
+    service.upsert_node(g, log, id="t:1", kind="T", labels=["B"], properties={"color": "blue"})
+    service.revert_event(log, log.tail(1)[0].id)
+
+    service.replay_log(g, log)
+    n = g.node("t:1")
+    assert sorted(n.labels) == ["A"] and n.properties == {"color": "red"}
+
+
+def test_resetting_existing_label_is_noop_not_logged(tmp_path):
+    """Re-adding a label a node already has must not log an event whose revert
+    would then remove the pre-existing label."""
+    from kgrdbms import service
+
+    g, log = _fresh(tmp_path)
+    service.upsert_node(g, log, id="t:1", kind="T", labels=["A"])
+    before = log.count()
+    service.set_label(g, log, "t:1", "A")            # already present -> no-op
+    assert log.count() == before                      # nothing logged
+    assert "A" in g.node("t:1").labels

{knowledge_graph_rdbms-0.1.2 → knowledge_graph_rdbms-0.1.3}/tests/test_rdf.py

@@ -97,6 +97,47 @@ def test_rdf_star_annotates_the_quoted_triple(populated):
     assert "<https://kg.local/prop/since>" in nt
 
 
+def test_special_chars_produce_valid_iris(populated):
+    """Regression: kind / edge-type / property-key with spaces or punctuation
+    must percent-encode into valid IRIs, not emit a raw space a store rejects."""
+    g = _fresh_graph()
+    g.add_node("topic:ml", kind="Knowledge Area", name="ML",
+               properties={"first name": "Ada", "rate %": 50, "a/b": 1})
+    g.add_node("topic:cs", kind="Knowledge Area", name="CS")
+    g.add_edge("topic:ml", "topic:cs", "is part of", properties={"note": "x"})
+
+    nt = rdf.export(g, "ntriples")
+    assert "Knowledge%20Area" in nt
+    assert "prop/first%20name" in nt
+    assert "rel/is%20part%20of" in nt
+    assert "prop/a%2Fb" in nt          # '/' encoded so it can't fake a path boundary
+    # No IRI reference may contain a raw space (would break any conformant parser).
+    import re
+    for iri in re.findall(r"<([^<>]+)>", nt):
+        assert " " not in iri, f"raw space in IRI: {iri!r}"
+
+
+def test_special_chars_round_trip_and_rdflib_accepts(populated):
+    rdflib = pytest.importorskip("rdflib")
+    g = _fresh_graph()
+    g.add_node("topic:ml", kind="Knowledge Area", name="ML",
+               properties={"first name": "Ada", "rate %": 50, "a/b": 1})
+    g.add_node("topic:cs", kind="Knowledge Area", name="CS")
+    g.add_edge("topic:ml", "topic:cs", "is part of", properties={"note": "x"})
+
+    # A conformant store accepts the export (reification — rdflib is RDF 1.1).
+    ctx = rdf.IriContext(edge_strategy="reification")
+    rdflib.Graph().parse(data=rdf.export(g, "ntriples", ctx), format="nt")
+
+    # And the values survive a full star round-trip unchanged.
+    dst = _reimport(rdf.export(g, "ntriples"), "ntriples")
+    n = dst.node("topic:ml")
+    assert n.kind == "Knowledge Area"
+    assert n.properties == {"first name": "Ada", "rate %": 50, "a/b": 1}
+    e = dst.out("topic:ml")[0][0]
+    assert e.type == "is part of" and e.properties == {"note": "x"}
+
+
 def test_reification_emits_statement_node(populated):
     ctx = rdf.IriContext(edge_strategy="reification")
     triples = rdf.export_graph(populated, ctx)