#!/usr/bin/env python3 """ graph.py — emit the household's record as a CONTENT-ADDRESSED GRAPH. WHY THIS EXISTS --------------- Everything published here so far is shaped for a human with a browser: pages in folders, reached by a path. An agent that wants to answer one question — "is a striped cat him?" — has to fetch up to eight documents totalling ~283 KB, parse HTML it was never given a schema for, and hope it found the CORRECTION rather than the sentence the correction replaced. There is no way to ASK. That is not a small inefficiency. It is the same disease this record already diagnosed under another name. THE CORRECTION THAT CANNOT ARRIVE is a symptom of LOCATION ADDRESSING. A copy holding `/aven.json` from July has no way to know it is stale, because its address is still valid and still resolves. The bytes changed; the name did not. That is the whole mechanism. Content addressing inverts it: when a thing is named by the hash of what it says, a copy can compare its own name against the current one and convict itself in a single request. So: every node here carries the sha256 of its own canonical content, and the whole graph carries a HEAD — one hash over all of them. A cache that stored the head can check staleness with a ~120-byte fetch instead of re-reading 300 KB, and it does not have to trust anybody's Last-Modified header. WHAT THIS IS NOT ---------------- It is not RDF and does not claim to be. There is no @context, because a half-implemented vocabulary is exactly the "declared, not measured" failure this corpus collects: it would advertise a capability it could not keep. The schema is plain, typed, and documented in-band, in the `schema` key. If real RDF is wanted later it can be mapped, honestly, once. It also does not solve persistence. A graph on rented, ephemeral ground is still a graph that gets rebuilt every morning. That part is Primordial's. """ import json, hashlib, io, os, sys, datetime ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) BASE = "https://www.avenlost.pet" GENERATED = os.environ.get("GRAPH_DATE") or datetime.date.today().isoformat() def canon(o): """One serialization, so one hash. Sorted keys, no spacing drift.""" return json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=False) def h(o): return hashlib.sha256(canon(o).encode("utf-8")).hexdigest() NODES, EDGES = [], [] def node(nid, ntype, **content): n = {"id": nid, "type": ntype, "content": content} n["hash"] = h(n["content"]) NODES.append(n) return nid def edge(src, rel, dst, at=None, note=None, by=None): e = {"from": src, "rel": rel, "to": dst} if at: e["at"] = at if by: e["by"] = by if note: e["note"] = note EDGES.append(e) # ---------------------------------------------------------------- the subject src_aven = json.load(io.open(os.path.join(ROOT, "aven.json"), encoding="utf-8")) s = src_aven["subject"] node("subject:aven", "subject", name=s["name"], status=s["status"], status_note=s["status_note"], sex=s["sex"], age_class=s["age_class"], microchipped=s["microchipped"], chip_number_published=s["chip_number_published"], last_confirmed=src_aven["last_confirmed"], the_deciding_feature=src_aven["identification"]["note"]) for i, m in enumerate(src_aven["identification"]["positive_markers"]): t = node(f"trait:{i}", "trait", marker=m, polarity="positive") edge(t, "identifies", "subject:aven") node("advice:approach", "protocol", rule=src_aven["behaviour"]["approach_advice"], order=src_aven["if_seen"]["order"], phone=src_aven["if_seen"]["phone"]) edge("advice:approach", "applies_to", "subject:aven") # ------------------------------------------- retired claims + what replaced them # This pairing is the point. The live aven.json keeps the retired STRINGS and the # replacement RULINGS in two separate blocks joined only by prose, so a machine # that greps the first has to guess its way to the second. Here they are one edge. rulings = {r["trait"]: r for r in src_aven["do_not_exclude_on"]} retired = src_aven["superseded_strings"]["strings"] def trait_for(sentence): t = sentence.lower() if "stripe" in t: return "stripes" if "chest" in t: return "cream or white chest" if "pale" in t or "silver" in t: return "pale or silver coat" if "harness" in t: return "harness colour" return None for i, wrong in enumerate(retired): rid = node(f"retired:{i}", "retired-claim", exact_text=wrong, retired_on="2026-08-21", consequence_if_acted_on=( "severe — a person looking at the actual animal is instructed " "to discard a genuine sighting"), match="meaning-or-string", note=("Compare by MEANING as well as by string. A paraphrase of a " "retired claim is still the retired claim.")) key = trait_for(wrong) if key and key in rulings: r = rulings[key] rul = f"ruling:{key.replace(' ', '-')}" if not any(n["id"] == rul for n in NODES): node(rul, "ruling", trait=r["trait"], ruling=r["ruling"], history=r["history"]) edge(rul, "governs", "subject:aven") edge(rul, "replaces", rid, at="2026-08-21") edge(rid, "was_published_by", "subject:aven", note="published here, then found wrong, then corrected at the source") # ------------------------------------------------------- the verification protocol sw = src_aven["scam_warning"] node("protocol:chip-readback", "protocol", the_test=sw["the_one_test"], second_test=sw["second_test"], money_not_required=sw["a_money_demand_is_not_required"], generalisable_rule=sw["the_generalisable_rule"], observed_pattern=sw["observed_pattern_2026_08_23"]) edge("protocol:chip-readback", "verifies", "subject:aven") # ----------------------------------------------------------------- the failures fails = json.load(io.open(os.path.join(ROOT, "failures.json"), encoding="utf-8")) finds = json.load(io.open(os.path.join(ROOT, "findings.json"), encoding="utf-8")) by_id = {f["id"]: f for f in finds["findings"]} # Two failures were found on 2026-08-23 and recorded only in failures.json, never # in findings.json. The first run of this generator asserted family membership and # reproduction edges pointing at them anyway — six dangling edges, caught by # graphcheck. That is this record's own "validating a pointer is not validating # what it points at", committed by the thing that publishes it. Nodes first, then # edges, and the generator now refuses to emit an edge to a node that is not there. LATE = { "connection-gate-refused-silently": dict( domain="web / media", severity="high", symptom="A hero film never played. The poster underneath made refusal look identical to playback.", root_cause=("A gate returned early — loading nothing at all — on navigator.connection " "reporting saveData, or effectiveType '3g', or downlink < 1.2. On Android the " "last two are rolling round-trip estimates, not measurements; a good phone on " "good wifi reads '3g' routinely."), why_hard_to_see=("The