rete-graph 0.2.0__tar.gz → 0.2.2__tar.gz

{rete_graph-0.2.0 → rete_graph-0.2.2}/Cargo.toml

@@ -14,7 +14,7 @@ members = [
 # release gates (--locked checks, feature matrix, coverage floors) stay
 # untouched by binding-only changes. Future clients (R, Go) follow the same
 # pattern — clients/ consumes crates/, never the other way around.
-exclude = ["fuzz", "clients/python"]
+exclude = ["fuzz", "clients/python", "clients/r/src/rust"]
 
 [workspace.package]
 version = "1.0.0-rc.1"

{rete_graph-0.2.0 → rete_graph-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rete-graph
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -43,6 +43,11 @@ CLI and the [browser playground](https://caviri.github.io/rete/playground.html).
 uv pip install rete-graph        # or: pip install rete-graph
 ```
 
+Wheels cover Linux (x86_64/aarch64), macOS, Windows — and, from 0.2.0,
+**browser Python**: in JupyterLite or marimo's WASM playground,
+`%pip install rete-graph` resolves a Pyodide (PyEmscripten) wheel and remote
+graphs are queried over sync-XHR range requests, no server anywhere.
+
 A runnable tour with captured outputs lives in
 [`examples/tutorial.ipynb`](examples/tutorial.ipynb).
 

{rete_graph-0.2.0/clients/python → rete_graph-0.2.2}/README.md

@@ -15,6 +15,11 @@ CLI and the [browser playground](https://caviri.github.io/rete/playground.html).
 uv pip install rete-graph        # or: pip install rete-graph
 ```
 
+Wheels cover Linux (x86_64/aarch64), macOS, Windows — and, from 0.2.0,
+**browser Python**: in JupyterLite or marimo's WASM playground,
+`%pip install rete-graph` resolves a Pyodide (PyEmscripten) wheel and remote
+graphs are queried over sync-XHR range requests, no server anywhere.
+
 A runnable tour with captured outputs lives in
 [`examples/tutorial.ipynb`](examples/tutorial.ipynb).
 

{rete_graph-0.2.0 → rete_graph-0.2.2}/clients/python/Cargo.lock

@@ -671,7 +671,7 @@ dependencies = [
 
 [[package]]
 name = "rete-python"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "pyo3",
  "rete-core",

{rete_graph-0.2.0 → rete_graph-0.2.2}/clients/python/Cargo.toml

@@ -5,7 +5,7 @@
 name = "rete-python"
 # Keep in lockstep with pyproject.toml's [project] version — __version__
 # comes from here (CARGO_PKG_VERSION), the wheel metadata from pyproject.
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/caviri/rete"

{rete_graph-0.2.0 → rete_graph-0.2.2/clients/python}/README.md

@@ -15,6 +15,11 @@ CLI and the [browser playground](https://caviri.github.io/rete/playground.html).
 uv pip install rete-graph        # or: pip install rete-graph
 ```
 
+Wheels cover Linux (x86_64/aarch64), macOS, Windows — and, from 0.2.0,
+**browser Python**: in JupyterLite or marimo's WASM playground,
+`%pip install rete-graph` resolves a Pyodide (PyEmscripten) wheel and remote
+graphs are queried over sync-XHR range requests, no server anywhere.
+
 A runnable tour with captured outputs lives in
 [`examples/tutorial.ipynb`](examples/tutorial.ipynb).
 

rete_graph-0.2.2/clients/python/examples/jupyterlite-build-tutorial.ipynb

@@ -0,0 +1,315 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "intro",
+   "metadata": {},
+   "source": [
+    "# Anatomy of a `.rete` — build one from an rdflib graph\n",
+    "\n",
+    "This notebook builds a **knowledge graph with a small ontology** in\n",
+    "[rdflib](https://rdflib.readthedocs.io), turns it into a **`.rete` file**,\n",
+    "and then dissects every part of that file: the **dictionary**, the **triple\n",
+    "indexes**, the **pyramid**, the **Dataset Card**, and the **embedded example\n",
+    "queries**. Everything runs in your browser tab (Pyodide + JupyterLite — no\n",
+    "server anywhere).\n",
+    "\n",
+    "Project: <https://github.com/caviri/rete> · docs:\n",
+    "[Python API](https://caviri.github.io/rete/python.html) ·\n",
+    "[format spec](https://caviri.github.io/rete/SPEC.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "install",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install rete-graph rdflib pandas\n",
+    "\n",
+    "import pandas as pd\n",
+    "import rdflib\n",
+    "import rete_graph as rete\n",
+    "print(f\"rete-graph {rete.__version__} · rdflib {rdflib.__version__}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "kg-md",
+   "metadata": {},
+   "source": [
+    "## 1. A small KG + ontology, in rdflib\n",
+    "\n",
+    "Eight bodies of the solar system, and — this is the part that makes the rest\n",
+    "of the notebook interesting — a tiny **ontology** on top: `Planet` and\n",
+    "`Moon` are both `rdfs:subClassOf` **`CelestialBody`**, and the `orbits`\n",
+    "property declares its domain and range. No instance is ever typed as a\n",
+    "`CelestialBody` directly; later, the reasoner will *infer* that they all are."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "kg",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from rdflib import RDF, RDFS, XSD, Literal, Namespace\n",
+    "\n",
+    "SOL = Namespace(\"https://example.org/solar/\")\n",
+    "kg = rdflib.Graph()\n",
+    "\n",
+    "# --- the ontology (TBox) ---\n",
+    "for cls in (\"CelestialBody\", \"Planet\", \"Moon\"):\n",
+    "    kg.add((SOL[cls], RDF.type, RDFS.Class))\n",
+    "kg.add((SOL.Planet, RDFS.subClassOf, SOL.CelestialBody))\n",
+    "kg.add((SOL.Moon, RDFS.subClassOf, SOL.CelestialBody))\n",
+    "kg.add((SOL.orbits, RDFS.domain, SOL.CelestialBody))\n",
+    "kg.add((SOL.orbits, RDFS.range, SOL.CelestialBody))\n",
+    "\n",
+    "# --- the data (ABox) ---\n",
+    "bodies = {\n",
+    "    \"Sun\":     (None,      None,   695_700),\n",
+    "    \"Mercury\": (\"Planet\", \"Sun\",     2_440),\n",
+    "    \"Venus\":   (\"Planet\", \"Sun\",     6_052),\n",
+    "    \"Earth\":   (\"Planet\", \"Sun\",     6_371),\n",
+    "    \"Moon\":    (\"Moon\",   \"Earth\",   1_737),\n",
+    "    \"Mars\":    (\"Planet\", \"Sun\",     3_390),\n",
+    "    \"Phobos\":  (\"Moon\",   \"Mars\",       11),\n",
+    "    \"Deimos\":  (\"Moon\",   \"Mars\",        6),\n",
+    "}\n",
+    "for name, (cls, parent, radius) in bodies.items():\n",
+    "    node = SOL[name]\n",
+    "    kg.add((node, RDFS.label, Literal(name, lang=\"en\")))\n",
+    "    kg.add((node, SOL.radius_km, Literal(radius, datatype=XSD.integer)))\n",
+    "    if cls:\n",
+    "        kg.add((node, RDF.type, SOL[cls]))\n",
+    "    if parent:\n",
+    "        kg.add((node, SOL.orbits, SOL[parent]))\n",
+    "\n",
+    "print(f\"{len(kg)} triples in the rdflib graph — a taste, as Turtle:\\n\")\n",
+    "print(\"\\n\".join(kg.serialize(format=\"turtle\").splitlines()[8:16]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "build-md",
+   "metadata": {},
+   "source": [
+    "## 2. From rdflib to `.rete` — what the Builder assembles\n",
+    "\n",
+    "`rete.Builder()` accepts the rdflib graph directly (anything with a\n",
+    "`.serialize()` method works). Configuration is **lazy** — each call just\n",
+    "records intent — and `run()` assembles the actual file, which is built from\n",
+    "four kinds of sections:\n",
+    "\n",
+    "| Part | What it is | Why it exists |\n",
+    "|---|---|---|\n",
+    "| **Dictionary** | every distinct term (IRI, literal, bnode) stored **once**, sorted, in role-split sections | queries compare small integer ids, not strings; sorted order → prefix lookups & compression |\n",
+    "| **Triple indexes** | the id-triples in **three permutations** (SPO / POS / OSP) with zone maps | any triple pattern — `(s ? ?)`, `(? p ?)`, `(? ? o)` — becomes a *range scan*, which is also what makes lazy HTTP-range querying possible |\n",
+    "| **Pyramid** | a leveled *summary* of the graph — communities of nodes, rolled up level by level, plus the label index | \"zoom out\" views, the schema profile, and label autocomplete, all readable without touching the big indexes |\n",
+    "| **Dataset Card** | a JSON self-description in the metadata section | the file documents itself: title, license, counts, and runnable starter queries |\n",
+    "\n",
+    "For the pyramid we choose `algo=\"types\"`: **one community per `rdf:type`\n",
+    "class** — for an ontology-shaped graph like ours, the summary *is* the class\n",
+    "structure. (The default, `louvain`, clusters by connectivity instead.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "build",
+   "metadata": {},
+   "outputs": [],
+   "source": "builder = (\n    rete.Builder()\n    .add(kg)                                  # the rdflib graph, directly\n    .card(\n        title=\"Solar system micro-KG\",\n        description=\"Eight bodies + a tiny ontology (Planet/Moon ⊑ CelestialBody), \"\n                    \"authored in rdflib inside a browser tab.\",\n        license=\"CC0-1.0\",\n        created=\"2026-07-17\",\n    )\n    .example(\n        \"SELECT ?body ?parent WHERE { ?body <https://example.org/solar/orbits> ?parent }\",\n        title=\"Who orbits whom?\",\n        question=\"Which body orbits which other body?\",\n    )\n    .example(\n        \"SELECT DISTINCT ?b WHERE { ?b a <https://example.org/solar/CelestialBody> }\",\n        title=\"All celestial bodies (needs reasoning!)\",\n        question=\"Which things are celestial bodies — including inferred ones?\",\n    )\n    .pyramid(algo=\"types\")                    # communities = classes\n    .text_index()                             # opt-in full-text index\n)\n\ndata = builder.run()\nprint(f\"{len(data):,} bytes\")\nbuilder.stats"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dict-md",
+   "metadata": {},
+   "source": [
+    "## 3. The dictionary — terms are stored once\n",
+    "\n",
+    "Look at `stats` above: the file holds more **statements** than **terms**.\n",
+    "Every IRI like `sol:Sun` appears in many triples but is written once; each\n",
+    "triple is just three small integers pointing into the dictionary. That's the\n",
+    "same trick as HDT and column stores — and because the dictionary is sorted\n",
+    "and chunked, a remote client can fetch *only the chunks a query touches* and\n",
+    "run **prefix searches** against the label index without a full scan:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dict",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g = builder.graph()\n",
+    "print(f\"statements: {g.quads} · distinct terms: {g.terms}\")\n",
+    "g.prefix_search(\"M\")   # label index: everything labelled M… (Moon, Mars, Mercury)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "pyramid-md",
+   "metadata": {},
+   "source": [
+    "## 4. The pyramid — the graph, summarized by class\n",
+    "\n",
+    "`pyramidLevels` in the build stats came from the `types` algorithm: level 0\n",
+    "groups every node under its `rdf:type` class, and the **schema profile** is\n",
+    "exactly that quotient graph — which classes exist, and how they relate\n",
+    "through predicates. A client reads this in a couple of small range requests\n",
+    "*before* deciding what to query — it's the \"map\" you see first in the\n",
+    "[playground](https://caviri.github.io/rete/playground.html):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "pyramid",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = g.schema()\n",
+    "display(pd.DataFrame(s[\"classes\"], columns=[\"class\", \"instances\"]))\n",
+    "pd.DataFrame(s[\"relations\"], columns=[\"subject class\", \"predicate\", \"object class\", \"count\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "card-md",
+   "metadata": {},
+   "source": [
+    "## 5. The Dataset Card — the file documents itself\n",
+    "\n",
+    "The card travels **inside** the file's metadata section. We wrote the curated\n",
+    "fields (`title`, `description`, `license`, `created`); the counts and\n",
+    "`format_version` were stamped automatically at build time. Every client reads\n",
+    "the same card — this notebook, the CLI (`rete card solar.rete`), the\n",
+    "playground's catalog view:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "card",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "card = g.card()\n",
+    "{k: card[k] for k in (\"title\", \"description\", \"license\", \"created\",\n",
+    "                       \"triple_count\", \"term_count\", \"format_version\")}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "examples-md",
+   "metadata": {},
+   "source": [
+    "## 6. Embedded example queries — a dataset that ships its own questions\n",
+    "\n",
+    "The two `.example()` calls landed in the card's starter-query library. Anyone\n",
+    "who opens this file — today or in ten years, in any client — can list them\n",
+    "and run them as-is:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "examples",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "examples = g.examples()\n",
+    "display(pd.DataFrame(examples)[[\"title\", \"question\"]])\n",
+    "g.query_df(examples[0][\"sparql\"])   # \"Who orbits whom?\", straight from the file"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "reason-md",
+   "metadata": {},
+   "source": [
+    "## 7. The ontology at work — reasoning by query rewriting\n",
+    "\n",
+    "Remember: nothing is *asserted* to be a `CelestialBody`. A plain query finds\n",
+    "nothing — but with `reason=True` the engine rewrites the query through the\n",
+    "ontology (`Planet ⊑ CelestialBody`, `Moon ⊑ CelestialBody`, plus the\n",
+    "`orbits` domain/range), computing OWL 2 QL entailment **without\n",
+    "materializing a single new triple**. That's why it works over lazy remote\n",
+    "files too:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "reason",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q = examples[1][\"sparql\"]           # \"All celestial bodies\" from the card\n",
+    "print(\"asserted only:\", len(g.query(q)), \"rows\")\n",
+    "print(\"with OWL 2 QL reasoning:\")\n",
+    "g.query_df(q, reason=True)          # planets, moons — and the Sun, via orbits' range"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "export-md",
+   "metadata": {},
+   "source": [
+    "## 8. Export — one immutable file, queryable anywhere\n",
+    "\n",
+    "`export()` writes the finished file (here into the notebook's in-browser\n",
+    "filesystem — check the file browser on the left; you can download it). Host\n",
+    "it on anything that serves HTTP `Range` and it is queryable in place from\n",
+    "Python, JavaScript, the CLI, and the playground — carrying its card, its\n",
+    "examples, and its ontology with it. For datasets beyond a few million\n",
+    "triples, graduate to the streaming\n",
+    "[`rete build` CLI](https://caviri.github.io/rete/cli.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "export",
+   "metadata": {},
+   "outputs": [],
+   "source": "path = builder.export(\"solar.rete\")\nreopened = rete.open(path)\nprint(path, \"·\", reopened.quads, \"triples · content hash\", reopened.content_hash())"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "outro",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "**Where next:** the [guided tour notebook](rete-graph.ipynb) (remote graphs,\n",
+    "lazy range reads) · [Python build tutorial](https://caviri.github.io/rete/python-build-tutorial.html) ·\n",
+    "[Dataset Cards](https://caviri.github.io/rete/dataset-cards.html) ·\n",
+    "[semantic zoom / pyramid](https://caviri.github.io/rete/semantic-zoom.html) ·\n",
+    "[reasoning](https://caviri.github.io/rete/reasoning.html)\n",
+    "\n",
+    "Source & issues: **<https://github.com/caviri/rete>**\n",
+    "\n",
+    "© 2026 Carlos Vivar Ríos — released under the\n",
+    "[Apache License 2.0](https://github.com/caviri/rete/blob/main/LICENSE)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (Pyodide)",
+   "language": "python",
+   "name": "python"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

rete_graph-0.2.2/clients/python/examples/jupyterlite-demo.ipynb

@@ -0,0 +1,209 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "intro",
+   "metadata": {},
+   "source": [
+    "# rete-graph, live in your browser\n",
+    "\n",
+    "**Everything in this notebook runs in your browser tab.** The Python you are\n",
+    "using is [Pyodide](https://pyodide.org) (CPython compiled to WebAssembly),\n",
+    "the notebook UI is [JupyterLite](https://jupyterlite.readthedocs.io) — and\n",
+    "the package under test is [`rete-graph`](https://pypi.org/project/rete-graph/),\n",
+    "whose PyEmscripten wheel installs straight from PyPI.\n",
+    "\n",
+    "A `.rete` file is a single, immutable, **range-queryable RDF graph**: it sits\n",
+    "on plain object storage, and the client fetches only the byte ranges a SPARQL\n",
+    "query touches. No database server anywhere — not even outside this tab.\n",
+    "\n",
+    "Run the cells top to bottom (`Shift+Enter`). The first one downloads the\n",
+    "wheel (~2 MB) and pandas, so give it a moment.\n",
+    "\n",
+    "Project: <https://github.com/caviri/rete> · docs:\n",
+    "[Python API](https://caviri.github.io/rete/python.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "install",
+   "metadata": {},
+   "outputs": [],
+   "source": "%pip install rete-graph pandas\n\nimport sys\nimport rete_graph as rete\nprint(f\"rete-graph {rete.__version__} running on platform: {sys.platform!r}\")"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "open-md",
+   "metadata": {},
+   "source": [
+    "## Open a remote graph — lazily\n",
+    "\n",
+    "The [BOE legal graph](https://caviri.github.io/rete/playground.html) (Spanish\n",
+    "state bulletin): **447,128 triples, 6.9 MB**, hosted on Cloudflare R2. Opening\n",
+    "it fetches only the header, dictionary directory, and index directories —\n",
+    "the kernel runs in a web worker, so the client's synchronous `XMLHttpRequest`\n",
+    "range reads are allowed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "open",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g = rete.open(\"https://data.graphplaza.com/boe/boe.rete\")\n",
+    "s = g.stats()\n",
+    "print(f\"{g.quads:,} triples available; opened after fetching just \"\n",
+    "      f\"{s['bytes']:,} of {s['fileLength']:,} bytes in {s['requests']} range requests\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "query-md",
+   "metadata": {},
+   "source": [
+    "## SPARQL → pandas\n",
+    "\n",
+    "`query_df()` runs a SPARQL SELECT and hands back a **pandas DataFrame**, so\n",
+    "results render as proper tables right here. This query lists laws that cite\n",
+    "the most other laws:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "query",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g.query_df(\"\"\"\n",
+    "    SELECT ?law (COUNT(?cited) AS ?cites) WHERE {\n",
+    "        ?law <http://data.europa.eu/eli/ontology#cites> ?cited\n",
+    "    }\n",
+    "    GROUP BY ?law ORDER BY DESC(?cites) LIMIT 10\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "examples-md",
+   "metadata": {},
+   "source": [
+    "## The dataset documents itself\n",
+    "\n",
+    "A `.rete` file can embed its own **Dataset Card** with a library of starter\n",
+    "queries. `examples()` reads them with one small ranged request — the table\n",
+    "below comes from *inside the file*, and every `sparql` entry is runnable:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "examples",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "examples = g.examples()\n",
+    "pd.DataFrame(examples)[[\"tier\", \"title\", \"question\"]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "run-example",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ... so let's run the first one, exactly as shipped in the file:\n",
+    "print(examples[0][\"title\"], \"—\", examples[0][\"question\"])\n",
+    "g.query_df(examples[0][\"sparql\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "schema-md",
+   "metadata": {},
+   "source": [
+    "## What's in the graph?\n",
+    "\n",
+    "The schema profile — which classes exist and how often — as another table:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "schema",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.DataFrame(g.schema()[\"classes\"], columns=[\"class\", \"instances\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "build-md",
+   "metadata": {},
+   "source": [
+    "## Build a graph of your own — in the browser\n",
+    "\n",
+    "The builder works here too: RDF in, an immutable `.rete` image out, with a\n",
+    "Dataset Card embedded. (For big datasets, use the\n",
+    "[`rete build` CLI](https://caviri.github.io/rete/cli.html).)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "build",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mine = (\n",
+    "    rete.Builder()\n",
+    "    .add('<urn:tab> <urn:runs> <urn:sparql> .\\n<urn:tab> <urn:needs> <urn:no_server> .')\n",
+    "    .card(title=\"Built inside a browser tab\", license=\"CC0-1.0\")\n",
+    "    .example(\"SELECT ?s ?p ?o WHERE { ?s ?p ?o }\", title=\"Everything\")\n",
+    "    .graph()\n",
+    ")\n",
+    "print(mine.card()[\"title\"], \"·\", mine.quads, \"triples\")\n",
+    "mine.query_df(mine.examples()[0][\"sparql\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "outro",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "**Where next:** the [playground](https://caviri.github.io/rete/playground.html)\n",
+    "(40+ datasets, no code) · [Python API](https://caviri.github.io/rete/python.html) ·\n",
+    "[build tutorial](https://caviri.github.io/rete/python-build-tutorial.html) ·\n",
+    "[JavaScript client](https://caviri.github.io/rete/javascript.html)\n",
+    "\n",
+    "Source & issues: **<https://github.com/caviri/rete>**\n",
+    "\n",
+    "© 2026 Carlos Vivar Ríos — released under the\n",
+    "[Apache License 2.0](https://github.com/caviri/rete/blob/main/LICENSE).\n",
+    "Datasets keep their own licenses (BOE: © Agencia Estatal Boletín Oficial del\n",
+    "Estado, [reuse conditions](https://www.boe.es/datosabiertos/))."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (Pyodide)",
+   "language": "python",
+   "name": "python"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{rete_graph-0.2.0 → rete_graph-0.2.2}/clients/python/src/lib.rs

@@ -18,7 +18,8 @@ use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 use rete_core::{
     eval_query, eval_query_reasoned, results_envelope_json, schema_classes, schema_summary,
-    BlockCacheReader, CountingReader, RangeReader, Rete, DEFAULT_BLOCK,
+    validate_shacl, BlockCacheReader, CountingReader, DataGraph, RangeReader, Rete, ReteGraph,
+    ShaclShapes, DEFAULT_BLOCK,
 };
 #[cfg(not(target_os = "emscripten"))]
 use rete_core::{parse_sparql_json_results, Binding, ServiceClient};
@@ -130,6 +131,38 @@ impl Graph {
 
 #[pymethods]
 impl Graph {
+    /// Validate the graph against SHACL Core shapes written in Turtle.
+    /// Lazy-aware: over the default graph only the shapes' targets are
+    /// fetched (the index is consulted in place); a named `graph` view
+    /// materializes that graph first. `format` is "json" (default) or "ttl".
+    #[pyo3(signature = (shapes_turtle, *, graph=None, format="json"))]
+    fn shacl(
+        &self,
+        py: Python<'_>,
+        shapes_turtle: &str,
+        graph: Option<&str>,
+        format: &str,
+    ) -> PyResult<String> {
+        let out = py
+            .allow_threads(|| -> Result<String, String> {
+                let shapes =
+                    ShaclShapes::parse_turtle(shapes_turtle).map_err(|e| e.to_string())?;
+                let report = match graph {
+                    None => validate_shacl(&ReteGraph::new(&self.rete), &shapes),
+                    Some(g) => {
+                        validate_shacl(&DataGraph::from_rete(&self.rete, Some(g)), &shapes)
+                    }
+                };
+                Ok(match format {
+                    "ttl" => report.to_turtle(),
+                    _ => report.to_json(),
+                })
+            })
+            .map_err(PyRuntimeError::new_err)?;
+        self.incomplete_guard()?;
+        Ok(out)
+    }
+
     /// Run a SPARQL query (SELECT / ASK / CONSTRUCT / DESCRIBE). Returns the
     /// JSON envelope `{"kind": "select", "vars": [...], "rows": [...]}` etc.;
     /// the Python wrapper parses it into values. `reason=True` turns on OWL 2