diffable-rdf 0.0.1__tar.gz

diffable_rdf-0.0.1/.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# Scratch (source extraction from upstream fork)
+_src/

diffable_rdf-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diffable_rdf-0.0.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: diffable-rdf
+Version: 0.0.1
+Summary: Deterministic, diff-stable serialization for rdflib graphs (RDFC-1.0 + Weisfeiler-Lehman blank-node hashing + idiomatic Turtle).
+Project-URL: Homepage, https://github.com/ASCS-eV/diffable-rdf
+Project-URL: Repository, https://github.com/ASCS-eV/diffable-rdf
+Project-URL: Issues, https://github.com/ASCS-eV/diffable-rdf/issues
+Author: ASCS e.V.
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: canonicalization,deterministic,diff,json-ld,pyoxigraph,rdf,rdfc-1.0,rdflib,serialization,turtle
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: pyoxigraph>=0.4.0
+Requires-Dist: rdflib>=6.0
+Description-Content-Type: text/markdown
+
+# diffable-rdf
+
+Deterministic, **diff-stable** serialization for [rdflib](https://rdflib.readthedocs.io/)
+graphs. Produces byte-identical Turtle across runs so version-controlled RDF
+artifacts (OWL ontologies, SHACL shapes, JSON-LD contexts) show minimal,
+meaningful diffs instead of blank-node churn.
+
+## Why
+
+RDF serializers assign blank-node identifiers (`_:c14nN`, `_:Nb1e2…`) based on
+process-dependent ordering. Regenerating an ontology therefore produces large,
+spurious diffs even when nothing semantically changed. `diffable-rdf` fixes this
+with a standards-based pipeline:
+
+1. **RDFC-1.0** ([W3C RDF Dataset Canonicalization](https://www.w3.org/TR/rdf-canon/))
+   via [pyoxigraph](https://pypi.org/project/pyoxigraph/) — isomorphic inputs
+   produce identical triple sets.
+2. **Weisfeiler-Lehman structural hashing** — replaces sequential `_:c14nN`
+   identifiers with content-based hashes that depend only on graph structure,
+   so adding/removing a triple only touches the directly involved blank nodes.
+3. **Idiomatic rdflib re-serialization** — inline blank nodes (`[ … ]`),
+   collection syntax (`( … )`), and filtered prefixes (only prefixes actually
+   used are declared).
+
+All triples are preserved; only syntactic form changes.
+
+## Install
+
+```bash
+pip install diffable-rdf
+# or
+uv add diffable-rdf
+```
+
+Requires Python 3.10+, `rdflib>=6`, and `pyoxigraph>=0.4`.
+
+## Usage
+
+```python
+from rdflib import Graph
+from diffable_rdf import deterministic_turtle
+
+g = Graph().parse("ontology.ttl")
+ttl = deterministic_turtle(g)          # diff-stable, idiomatic Turtle
+open("ontology.ttl", "w", newline="\n").write(ttl)
+```
+
+Other entry points:
+
+```python
+from diffable_rdf import canonicalize_rdf_graph, deterministic_json, well_known_prefix_map
+
+canonicalize_rdf_graph(graph, "turtle")   # lower-level RDFC-1.0 canonical form
+deterministic_json(obj)                    # recursively key/list-sorted JSON(-LD)
+well_known_prefix_map()                    # namespace IRI -> standard prefix name
+```
+
+## API
+
+| Function | Purpose |
+|---|---|
+| `deterministic_turtle(graph) -> str` | Diff-stable, idiomatic Turtle (RDFC-1.0 + WL hashing + rdflib re-serialize). |
+| `canonicalize_rdf_graph(graph, output_format="turtle") -> str` | RDFC-1.0 canonical serialization (with rdflib fallback for non-standard RDF). |
+| `deterministic_json(obj, indent=3, preserve_list_order_keys=None) -> str` | Recursively sorted JSON; preserves JSON-LD ordered keys (`@context`, `@list`, …). |
+| `well_known_prefix_map() -> dict[str, str]` | rdflib's curated namespace→prefix bindings. |
+
+## Provenance
+
+Extracted from the diff-stabilization work in
+[`ASCS-eV/linkml#1`](https://github.com/ASCS-eV/linkml/pull/1) (itself a
+review-ready rework of upstream [`linkml/linkml#3295`](https://github.com/linkml/linkml/pull/3295))
+into a small, tool-agnostic library so LinkML, ShapeChange output, and other RDF
+toolchains can share one canonicalizer.
+
+## License
+
+[Apache-2.0](LICENSE)

diffable_rdf-0.0.1/README.md

@@ -0,0 +1,77 @@
+# diffable-rdf
+
+Deterministic, **diff-stable** serialization for [rdflib](https://rdflib.readthedocs.io/)
+graphs. Produces byte-identical Turtle across runs so version-controlled RDF
+artifacts (OWL ontologies, SHACL shapes, JSON-LD contexts) show minimal,
+meaningful diffs instead of blank-node churn.
+
+## Why
+
+RDF serializers assign blank-node identifiers (`_:c14nN`, `_:Nb1e2…`) based on
+process-dependent ordering. Regenerating an ontology therefore produces large,
+spurious diffs even when nothing semantically changed. `diffable-rdf` fixes this
+with a standards-based pipeline:
+
+1. **RDFC-1.0** ([W3C RDF Dataset Canonicalization](https://www.w3.org/TR/rdf-canon/))
+   via [pyoxigraph](https://pypi.org/project/pyoxigraph/) — isomorphic inputs
+   produce identical triple sets.
+2. **Weisfeiler-Lehman structural hashing** — replaces sequential `_:c14nN`
+   identifiers with content-based hashes that depend only on graph structure,
+   so adding/removing a triple only touches the directly involved blank nodes.
+3. **Idiomatic rdflib re-serialization** — inline blank nodes (`[ … ]`),
+   collection syntax (`( … )`), and filtered prefixes (only prefixes actually
+   used are declared).
+
+All triples are preserved; only syntactic form changes.
+
+## Install
+
+```bash
+pip install diffable-rdf
+# or
+uv add diffable-rdf
+```
+
+Requires Python 3.10+, `rdflib>=6`, and `pyoxigraph>=0.4`.
+
+## Usage
+
+```python
+from rdflib import Graph
+from diffable_rdf import deterministic_turtle
+
+g = Graph().parse("ontology.ttl")
+ttl = deterministic_turtle(g)          # diff-stable, idiomatic Turtle
+open("ontology.ttl", "w", newline="\n").write(ttl)
+```
+
+Other entry points:
+
+```python
+from diffable_rdf import canonicalize_rdf_graph, deterministic_json, well_known_prefix_map
+
+canonicalize_rdf_graph(graph, "turtle")   # lower-level RDFC-1.0 canonical form
+deterministic_json(obj)                    # recursively key/list-sorted JSON(-LD)
+well_known_prefix_map()                    # namespace IRI -> standard prefix name
+```
+
+## API
+
+| Function | Purpose |
+|---|---|
+| `deterministic_turtle(graph) -> str` | Diff-stable, idiomatic Turtle (RDFC-1.0 + WL hashing + rdflib re-serialize). |
+| `canonicalize_rdf_graph(graph, output_format="turtle") -> str` | RDFC-1.0 canonical serialization (with rdflib fallback for non-standard RDF). |
+| `deterministic_json(obj, indent=3, preserve_list_order_keys=None) -> str` | Recursively sorted JSON; preserves JSON-LD ordered keys (`@context`, `@list`, …). |
+| `well_known_prefix_map() -> dict[str, str]` | rdflib's curated namespace→prefix bindings. |
+
+## Provenance
+
+Extracted from the diff-stabilization work in
+[`ASCS-eV/linkml#1`](https://github.com/ASCS-eV/linkml/pull/1) (itself a
+review-ready rework of upstream [`linkml/linkml#3295`](https://github.com/linkml/linkml/pull/3295))
+into a small, tool-agnostic library so LinkML, ShapeChange output, and other RDF
+toolchains can share one canonicalizer.
+
+## License
+
+[Apache-2.0](LICENSE)

diffable_rdf-0.0.1/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "diffable-rdf"
+dynamic = ["version"]
+description = "Deterministic, diff-stable serialization for rdflib graphs (RDFC-1.0 + Weisfeiler-Lehman blank-node hashing + idiomatic Turtle)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "ASCS e.V." }]
+keywords = [
+    "rdf",
+    "rdflib",
+    "turtle",
+    "canonicalization",
+    "rdfc-1.0",
+    "deterministic",
+    "diff",
+    "serialization",
+    "json-ld",
+    "pyoxigraph",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Markup",
+    "Typing :: Typed",
+]
+dependencies = [
+    "rdflib>=6.0",
+    "pyoxigraph>=0.4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ASCS-eV/diffable-rdf"
+Repository = "https://github.com/ASCS-eV/diffable-rdf"
+Issues = "https://github.com/ASCS-eV/diffable-rdf/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+]
+
+[tool.hatch.version]
+path = "src/diffable_rdf/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/diffable_rdf"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/diffable_rdf",
+    "tests",
+    "README.md",
+    "LICENSE",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

diffable_rdf-0.0.1/src/diffable_rdf/__init__.py

@@ -0,0 +1,24 @@
+"""diffable-rdf: deterministic, diff-stable serialization for rdflib graphs.
+
+Public API:
+    deterministic_turtle(graph)            -> diff-stable idiomatic Turtle
+    canonicalize_rdf_graph(graph, format)  -> RDFC-1.0 canonical serialization
+    deterministic_json(obj)                -> deterministically ordered JSON
+    well_known_prefix_map()                -> namespace IRI -> standard prefix
+"""
+
+from __future__ import annotations
+
+from diffable_rdf.canonicalize import canonicalize_rdf_graph
+from diffable_rdf.jsonld import deterministic_json
+from diffable_rdf.turtle import deterministic_turtle, well_known_prefix_map
+
+__all__ = [
+    "deterministic_turtle",
+    "canonicalize_rdf_graph",
+    "deterministic_json",
+    "well_known_prefix_map",
+    "__version__",
+]
+
+__version__ = "0.0.1"

diffable_rdf-0.0.1/src/diffable_rdf/canonicalize.py

@@ -0,0 +1,226 @@
+"""Deterministic RDF serialization via pyoxigraph RDFC-1.0 canonicalization.
+
+This module provides a function to canonicalize an rdflib Graph using
+pyoxigraph's RDFC-1.0 implementation, producing deterministic output
+with stable blank node labels and sorted triples.
+
+**Known limitations:**
+
+1. **xsd:string normalization**: pyoxigraph follows RDF 1.1, where plain
+   string literals and ``"text"^^xsd:string`` are identical.  The output
+   will never contain explicit ``^^xsd:string`` annotations.  Code that
+   re-parses the output with rdflib will see ``Literal("x")`` (datatype
+   ``None``) rather than ``Literal("x", datatype=XSD.string)``.
+
+2. **Non-standard RDF**: Graphs with literal predicates (e.g. SHACL
+   annotation mode) are rejected by pyoxigraph.  This function falls
+   back to rdflib's serializer for such graphs.
+
+3. **Numeric short forms**: pyoxigraph uses Turtle short forms for
+   ``xsd:integer`` (``42``), ``xsd:boolean`` (``true``), and
+   ``xsd:decimal`` (``1.23``).  rdflib parses these back with the
+   correct datatype, so this is lossless.
+
+4. **Base IRI / prefix collision**: When a graph has ``@base`` and a
+   prefix whose namespace equals the base IRI (e.g. rdflib's auto-bound
+   ``base:`` prefix), pyoxigraph emits CURIEs like ``base:label`` that
+   rdflib rejects.  We skip such prefixes during serialization.
+
+5. **Trailing escaped dot in PN_LOCAL**: pyoxigraph emits CURIEs like
+   ``prefix:local\\.`` for IRIs whose local part ends with ``.``.  This
+   is valid Turtle (PN_LOCAL_ESC), but rdflib's notation3 parser rejects
+   it because it conflicts with the statement-terminator dot.  We
+   post-process the output to expand such CURIEs to full ``<IRI>`` form.
+"""
+
+import io
+import logging
+import re
+
+import pyoxigraph as ox
+import rdflib
+
+logger = logging.getLogger(__name__)
+
+# Mapping from rdflib format strings to pyoxigraph RdfFormat objects.
+_FORMAT_MAP: dict[str, ox.RdfFormat] = {
+    "turtle": ox.RdfFormat.TURTLE,
+    "ttl": ox.RdfFormat.TURTLE,
+    "nt": ox.RdfFormat.N_TRIPLES,
+    "ntriples": ox.RdfFormat.N_TRIPLES,
+    "n-triples": ox.RdfFormat.N_TRIPLES,
+    "nt11": ox.RdfFormat.N_TRIPLES,
+    "nquads": ox.RdfFormat.N_QUADS,
+    "n-quads": ox.RdfFormat.N_QUADS,
+    "xml": ox.RdfFormat.RDF_XML,
+    "rdf/xml": ox.RdfFormat.RDF_XML,
+    "trig": ox.RdfFormat.TRIG,
+    "n3": ox.RdfFormat.N3,
+}
+
+# Formats that support prefix declarations.
+_PREFIX_FORMATS = frozenset({ox.RdfFormat.TURTLE, ox.RdfFormat.TRIG, ox.RdfFormat.N3, ox.RdfFormat.RDF_XML})
+
+
+# Characters that may appear escaped in a Turtle PN_LOCAL via PN_LOCAL_ESC.
+_PN_LOCAL_ESC_UNESCAPE = re.compile(r"\\([_~.\-!$&'()*+,;=/?#@%])")
+
+
+def _expand_trailing_dot_curies(turtle_text: str, prefixes: dict[str, str]) -> str:
+    """Replace CURIEs whose local part ends in ``\\.`` with full ``<IRI>`` form.
+
+    rdflib's notation3 parser rejects PN_LOCAL ending in an escaped dot
+    even though Turtle permits it (PN_LOCAL_ESC).  pyoxigraph emits this
+    form for IRIs ending in ``.`` (e.g. ``biolink:StrandEnum#.``).  We
+    rewrite each such CURIE to its expanded ``<IRI>`` form so the output
+    round-trips through rdflib.
+    """
+    if not prefixes:
+        return turtle_text
+
+    # Match: a prefix name, ':', a local part (no whitespace or token
+    # delimiters), ending in ``\.``, followed by whitespace.  Use a
+    # negative lookbehind to avoid matching inside ``<...>`` or word
+    # characters that would make this a substring of something else.
+    pattern = re.compile(
+        r"(?<![<\w])"
+        r"([A-Za-z_][\w.-]*?):"
+        r"([^\s,;()<>\"'\[\]]*?\\\.)"
+        r"(?=\s)"
+    )
+
+    def replace(match: re.Match[str]) -> str:
+        prefix = match.group(1)
+        local_escaped = match.group(2)
+        namespace = prefixes.get(prefix)
+        if namespace is None:
+            return match.group(0)
+        local = _PN_LOCAL_ESC_UNESCAPE.sub(r"\1", local_escaped)
+        return f"<{namespace}{local}>"
+
+    return pattern.sub(replace, turtle_text)
+
+
+def _is_safe_prefix_iri(iri: str) -> bool:
+    """Check whether a namespace IRI is safe for prefix serialization.
+
+    pyoxigraph rejects IRIs with invalid code-points (e.g. double ``#``),
+    and rdflib's Turtle parser cannot round-trip CURIEs whose namespace
+    contains query parameters or fragments in unexpected positions.  This
+    function returns ``False`` for such IRIs so they can be skipped during
+    prefix collection.
+    """
+    # A namespace IRI should end with '/' or '#'.  If '#' appears
+    # *before* the final character, the IRI contains an embedded
+    # fragment which produces unusable CURIEs.
+    if "#" in iri[:-1]:
+        return False
+    # Query parameters in namespace IRIs produce CURIEs that rdflib
+    # cannot parse back.
+    if "?" in iri:
+        return False
+    return True
+
+
+def canonicalize_rdf_graph(
+    graph: rdflib.Graph,
+    output_format: str = "turtle",
+) -> str:
+    """Serialize an rdflib Graph deterministically using RDFC-1.0 canonicalization.
+
+    The graph is transferred to pyoxigraph via N-Triples, canonicalized
+    with RDFC-1.0, sorted, and serialized back to the requested format.
+    Prefix bindings from the rdflib Graph are preserved in the output
+    for formats that support them (Turtle, TriG, N3, RDF/XML).
+
+    Falls back to plain rdflib serialization for unsupported formats or
+    graphs containing non-standard RDF (e.g. literal predicates).
+
+    :param graph: The rdflib Graph to serialize.
+    :param output_format: Target serialization format (e.g. ``"turtle"``, ``"nt"``).
+    :return: Deterministic string serialization of the graph.
+    """
+    ox_format = _FORMAT_MAP.get(output_format.lower())
+    if ox_format is None:
+        logger.warning(
+            "pyoxigraph does not support format %r; falling back to rdflib serializer",
+            output_format,
+        )
+        # rdflib's Turtle serializer emits a trailing double newline;
+        # normalize to single newline for consistent file endings.
+        data = graph.serialize(format=output_format)
+        return data.rstrip("\n") + "\n" if data.endswith("\n") else data
+
+    # 1. Transfer rdflib graph to pyoxigraph via N-Triples.
+    nt_data = graph.serialize(format="nt")
+    nt_bytes = nt_data.encode("utf-8") if isinstance(nt_data, str) else nt_data
+
+    # 2. Parse into pyoxigraph and build a Dataset for canonicalization.
+    #    Fall back to rdflib if the graph contains non-standard RDF
+    #    (e.g. literal predicates from annotations) that pyoxigraph rejects.
+    try:
+        triples = list(ox.parse(io.BytesIO(nt_bytes), format=ox.RdfFormat.N_TRIPLES))
+    except SyntaxError:
+        logger.warning(
+            "Graph contains non-standard RDF that pyoxigraph cannot parse; falling back to rdflib serializer"
+        )
+        return graph.serialize(format=output_format)
+
+    dataset = ox.Dataset()
+    for triple in triples:
+        dataset.add(ox.Quad(triple.subject, triple.predicate, triple.object, ox.DefaultGraph()))
+
+    # 3. Canonicalize blank node labels with RDFC-1.0.
+    dataset.canonicalize(ox.CanonicalizationAlgorithm.RDFC_1_0)
+
+    # 4. Sort triples for deterministic ordering.
+    quads = list(dataset)
+    sorted_triples = sorted(
+        (ox.Triple(q.subject, q.predicate, q.object) for q in quads),
+        key=lambda t: (str(t.subject), str(t.predicate), str(t.object)),
+    )
+
+    # 5. Collect prefixes for formats that support them.
+    base_iri = str(graph.base) if graph.base else None
+    prefixes: dict[str, str] | None = None
+    if ox_format in _PREFIX_FORMATS:
+        prefixes = {}
+        for prefix, namespace in graph.namespace_manager.namespaces():
+            if not prefix:  # skip empty prefix (base)
+                continue
+            ns_str = str(namespace)
+            # Skip prefixes whose namespace matches the base IRI to avoid
+            # pyoxigraph emitting CURIEs like `base:label` that conflict
+            # with the @base directive.
+            if base_iri and ns_str == base_iri:
+                continue
+            # Skip namespace IRIs that pyoxigraph rejects or that produce
+            # CURIEs rdflib cannot round-trip.  Valid namespace IRIs for
+            # prefix use should end with '/' or '#' and contain no query
+            # parameters or fragment-like characters in the middle.
+            if not _is_safe_prefix_iri(ns_str):
+                continue
+            prefixes[str(prefix)] = ns_str
+    used_prefixes = prefixes
+    try:
+        result_bytes = ox.serialize(
+            sorted_triples,
+            format=ox_format,
+            prefixes=prefixes,
+            base_iri=base_iri,
+        )
+    except ValueError:
+        # pyoxigraph rejects prefixes with invalid IRIs (e.g. containing
+        # fragment-like characters such as double '#').  Retry without
+        # the offending prefixes by falling back to no prefixes, which
+        # still produces valid (if verbose) Turtle.
+        logger.warning("pyoxigraph rejected one or more prefix IRIs; serializing without prefix declarations")
+        result_bytes = ox.serialize(
+            sorted_triples,
+            format=ox_format,
+        )
+        used_prefixes = None
+    result = result_bytes.decode("utf-8")
+    if ox_format in _PREFIX_FORMATS and used_prefixes:
+        result = _expand_trailing_dot_curies(result, used_prefixes)
+    return result

diffable_rdf-0.0.1/src/diffable_rdf/jsonld.py

@@ -0,0 +1,50 @@
+"""Deterministic JSON / JSON-LD serialization (recursive key + list sort)."""
+
+from __future__ import annotations
+
+import json
+
+# JSON-LD keys whose array values carry ordering semantics and must NOT be
+# sorted.  ``@context`` arrays define an override cascade (JSON-LD 1.1 §4.1);
+# ``@list`` containers are explicitly ordered; ``@graph``/``@set`` and
+# ``imports`` are included defensively.
+_JSONLD_ORDERED_KEYS: frozenset[str] = frozenset({"@context", "@list", "@graph", "@set", "imports"})
+
+
+def deterministic_json(
+    obj: object,
+    indent: int = 3,
+    preserve_list_order_keys: frozenset[str] | None = None,
+) -> str:
+    """Serialize a JSON-compatible object with deterministic ordering.
+
+    Recursively sorts all dict keys *and* list elements to produce stable
+    output across Python versions and process invocations.
+
+    List elements are sorted by their canonical JSON representation
+    (``json.dumps(item, sort_keys=True)``), which handles lists of dicts,
+    strings, and mixed types.
+
+    :param obj: A JSON-serializable object.
+    :param indent: Number of spaces for indentation.
+    :param preserve_list_order_keys: Dict keys whose list values must NOT be
+        sorted (e.g. ``@context``, ``@list`` in JSON-LD where array order is
+        semantic).  Defaults to :data:`_JSONLD_ORDERED_KEYS`.
+    :returns: Deterministic JSON string.
+    """
+    skip = preserve_list_order_keys if preserve_list_order_keys is not None else _JSONLD_ORDERED_KEYS
+
+    def _deep_sort(value: object, parent_key: str = "") -> object:
+        if isinstance(value, dict):
+            return {k: _deep_sort(v, parent_key=k) for k, v in sorted(value.items())}
+        if isinstance(value, list):
+            sorted_items = [_deep_sort(item) for item in value]
+            if parent_key in skip:
+                return sorted_items
+            try:
+                return sorted(sorted_items, key=lambda x: json.dumps(x, sort_keys=True, ensure_ascii=False))
+            except TypeError:
+                return sorted_items
+        return value
+
+    return json.dumps(_deep_sort(obj), indent=indent, ensure_ascii=False)

diffable_rdf-0.0.1/src/diffable_rdf/py.typed

@@ -0,0 +1 @@
+# Marker file (PEP 561): ship inline type hints to consumers.

diffable_rdf-0.0.1/src/diffable_rdf/turtle.py

@@ -0,0 +1,268 @@
+"""Deterministic, diff-stable Turtle serialization for rdflib graphs.
+
+Three-phase hybrid pipeline: RDFC-1.0 canonicalization (pyoxigraph) ->
+Weisfeiler-Lehman blank-node hashing -> idiomatic rdflib re-serialization.
+
+Extracted from ASCS-eV/linkml (feat/deterministic-output, PR #1) into a
+standalone, tool-agnostic library.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rdflib import Graph as RdfGraph
+
+logger = logging.getLogger(__name__)
+
+
+def _wl_signatures(
+    quads: list,
+    iterations: int = 4,
+) -> dict[str, str]:
+    """Compute Weisfeiler-Lehman structural signatures for blank nodes.
+
+    Uses 1-dimensional WL colour refinement [1]_ to assign each blank
+    node a deterministic signature derived from its multi-hop
+    neighbourhood structure.  The signature depends only on predicate
+    IRIs, literal values, and named-node IRIs — **not** on blank-node
+    identifiers — so it remains stable when unrelated triples are added
+    or removed.
+
+    Parameters
+    ----------
+    quads : list
+        Canonical quads from pyoxigraph (after RDFC-1.0).
+    iterations : int
+        Number of WL refinement rounds (default 4).
+
+    Returns
+    -------
+    dict[str, str]
+        Mapping from canonical blank-node ID (e.g. ``c14n42``) to a
+        truncated SHA-256 hash suitable for use as a stable blank-node
+        label.
+
+    References
+    ----------
+    .. [1] Weisfeiler, B. & Leman, A. (1968). "The reduction of a graph
+       to canonical form and the algebra which appears therein."
+    """
+    import hashlib
+
+    import pyoxigraph  # guaranteed available — caller (deterministic_turtle) checks
+
+    # Collect all blank node IDs and build adjacency index.
+    bnode_ids: set[str] = set()
+    # outgoing[b] = list of (predicate_str, object_str_or_bnode_id, is_bnode)
+    outgoing: dict[str, list[tuple[str, str, bool]]] = {}
+    # incoming[b] = list of (subject_str_or_bnode_id, predicate_str, is_bnode)
+    incoming: dict[str, list[tuple[str, str, bool]]] = {}
+
+    for q in quads:
+        s, p, o = q.subject, q.predicate, q.object
+        s_is_bn = isinstance(s, pyoxigraph.BlankNode)
+        o_is_bn = isinstance(o, pyoxigraph.BlankNode)
+        p_str = str(p)
+
+        if s_is_bn:
+            bnode_ids.add(s.value)
+            outgoing.setdefault(s.value, []).append((p_str, o.value if o_is_bn else str(o), o_is_bn))
+        if o_is_bn:
+            bnode_ids.add(o.value)
+            incoming.setdefault(o.value, []).append((s.value if s_is_bn else str(s), p_str, s_is_bn))
+
+    # Initialise signatures: named-node edges only (no bnode IDs).
+    sig: dict[str, str] = {}
+    for bid in bnode_ids:
+        parts = []
+        for p_str, o_str, o_is_bn in outgoing.get(bid, []):
+            if not o_is_bn:
+                parts.append(f"+{p_str}={o_str}")
+        for s_str, p_str, s_is_bn in incoming.get(bid, []):
+            if not s_is_bn:
+                parts.append(f"-{s_str}={p_str}")
+        sig[bid] = "|".join(sorted(parts))
+
+    # Iterative refinement: incorporate neighbour signatures.
+    for _ in range(iterations):
+        new_sig: dict[str, str] = {}
+        for bid in bnode_ids:
+            parts = [sig[bid]]
+            for p_str, o_str, o_is_bn in outgoing.get(bid, []):
+                if o_is_bn:
+                    parts.append(f"+{p_str}={sig.get(o_str, '')}")
+            for s_str, p_str, s_is_bn in incoming.get(bid, []):
+                if s_is_bn:
+                    parts.append(f"-{sig.get(s_str, '')}={p_str}")
+            new_sig[bid] = "|".join(sorted(parts))
+        sig = new_sig
+
+    # Convert signatures to truncated SHA-256 hashes.
+    # Use 12 hex chars (48 bits) — birthday-bound collision probability
+    # is ~n²/2^49: ~0.002% at 100k nodes.  Collisions are handled by
+    # appending a counter (see below), so correctness is preserved.
+    hash_map: dict[str, str] = {}
+    seen_hashes: dict[str, int] = {}
+    for bid in sorted(bnode_ids):
+        digest = hashlib.sha256(sig[bid].encode("utf-8")).hexdigest()[:12]
+        # Handle collisions by appending a counter.
+        count = seen_hashes.get(digest, 0)
+        seen_hashes[digest] = count + 1
+        label = f"b{digest}" if count == 0 else f"b{digest}_{count}"
+        hash_map[bid] = label
+
+    return hash_map
+
+
+
+
+def deterministic_turtle(graph: "RdfGraph") -> str:
+    """Serialize an RDF graph to Turtle with deterministic output ordering.
+
+    Uses a three-phase hybrid pipeline for **correctness**, **diff
+    stability**, and **readability**:
+
+    1. **RDFC-1.0** [1]_ (via ``pyoxigraph``) canonicalizes the graph,
+       ensuring isomorphic inputs produce identical triple sets.
+    2. **Weisfeiler-Lehman structural hashing** replaces the sequential
+       ``_:c14nN`` identifiers with content-based hashes derived from
+       each blank node's multi-hop neighbourhood.  These hashes depend
+       only on predicate IRIs, literal values, and named-node IRIs —
+       not on blank-node numbering — so adding or removing a triple
+       only affects the identifiers of directly involved blank nodes.
+    3. **Hybrid rdflib re-serialization** parses the canonicalized,
+       WL-hashed triples back into an rdflib ``Graph`` and serializes
+       with rdflib's native Turtle writer.  This recovers idiomatic
+       Turtle features that pyoxigraph cannot emit:
+
+       - **Inline blank nodes** (``[ … ]``) for singly-referenced
+         blank nodes (Turtle §2.7 [2]_), instead of verbose named
+         ``_:bHASH`` syntax.
+       - **Collection syntax** (``( … )``) for ``rdf:List`` chains
+         (Turtle §2.8 [2]_).
+       - **Prefix filtering**: only prefixes actually used in the
+         graph's IRIs are declared, following the practice of Apache
+         Jena, Eclipse RDF4J, and Raptor.
+
+    All triples from the source graph are preserved — the hybrid step
+    only changes syntactic form, never semantic content.
+
+    Parameters
+    ----------
+    graph : rdflib.Graph
+        An rdflib Graph to serialize.
+
+    Returns
+    -------
+    str
+        Deterministic Turtle string with ``@prefix`` declarations.
+
+    References
+    ----------
+    .. [1] W3C (2024). "RDF Dataset Canonicalization (RDFC-1.0)."
+       W3C Recommendation.  https://www.w3.org/TR/rdf-canon/
+    .. [2] W3C (2014). "RDF 1.1 Turtle — Terse RDF Triple Language."
+       W3C Recommendation.  https://www.w3.org/TR/turtle/
+    """
+    try:
+        import pyoxigraph
+    except ImportError as exc:
+        raise ImportError(
+            "pyoxigraph >= 0.4.0 is required for --deterministic output. "
+            "Install it with: pip install 'pyoxigraph>=0.4.0'"
+        ) from exc
+
+    from rdflib import BNode, Graph, Literal, URIRef
+
+    # ── Phase 1: RDFC-1.0 canonicalization ──────────────────────────
+    nt_data = graph.serialize(format="nt")
+
+    dataset = pyoxigraph.Dataset(pyoxigraph.parse(nt_data, format=pyoxigraph.RdfFormat.N_TRIPLES))
+    dataset.canonicalize(pyoxigraph.CanonicalizationAlgorithm.RDFC_1_0)
+
+    canonical_quads = list(dataset)
+
+    # ── Phase 2: WL structural hashing for diff-stable blank node IDs
+    wl_map = _wl_signatures(canonical_quads)
+
+    def _remap(term):
+        if isinstance(term, pyoxigraph.BlankNode) and term.value in wl_map:
+            return pyoxigraph.BlankNode(wl_map[term.value])
+        return term
+
+    remapped = [pyoxigraph.Triple(_remap(q.subject), q.predicate, _remap(q.object)) for q in canonical_quads]
+
+    # ── Phase 3: Hybrid rdflib re-serialization ─────────────────────
+    # Convert pyoxigraph terms to rdflib terms and populate a clean
+    # Graph that only carries explicitly-bound prefixes.
+    def _to_rdflib(term):
+        """Convert a pyoxigraph term to the equivalent rdflib term."""
+        if isinstance(term, pyoxigraph.NamedNode):
+            return URIRef(term.value)
+        if isinstance(term, pyoxigraph.BlankNode):
+            return BNode(term.value)
+        if isinstance(term, pyoxigraph.Literal):
+            if term.language:
+                return Literal(term.value, lang=term.language)
+            if term.datatype:
+                dt_iri = term.datatype.value
+                # In RDF 1.1, simple literals are syntactic sugar for
+                # xsd:string (Turtle §2.5.1).  Preserve the shorter form
+                # to match the original owlgen output and avoid spurious
+                # diffs on every string literal.
+                if dt_iri == "http://www.w3.org/2001/XMLSchema#string":
+                    return Literal(term.value)
+                return Literal(term.value, datatype=URIRef(dt_iri))
+            return Literal(term.value)
+        raise TypeError(f"Unexpected pyoxigraph term type: {type(term).__name__}: {term}")
+
+    result_graph = Graph(bind_namespaces="none")
+    for triple in remapped:
+        result_graph.add(
+            (
+                _to_rdflib(triple.subject),
+                _to_rdflib(triple.predicate),
+                _to_rdflib(triple.object),
+            )
+        )
+
+    # Bind only prefixes whose namespace IRI is actually referenced
+    # by at least one subject, predicate, or object in the graph.
+    # This filters out rdflib's ~27 built-in default bindings
+    # (brick, csvw, doap, …) that leak through Graph() even when
+    # the schema never declared them.
+    used_iris: set[str] = set()
+    for s, p, o in result_graph:
+        for term in (s, p, o):
+            if isinstance(term, URIRef):
+                used_iris.add(str(term))
+
+    for pfx, ns in sorted(graph.namespaces()):
+        pfx_s, ns_s = str(pfx), str(ns)
+        if pfx_s and any(iri.startswith(ns_s) for iri in used_iris):
+            result_graph.bind(pfx_s, ns_s)
+
+    # rdflib's Turtle serializer always emits a trailing double newline;
+    # normalize to a single newline for consistent file endings.
+    return result_graph.serialize(format="turtle").rstrip("\n") + "\n"
+
+
+
+
+def well_known_prefix_map() -> dict[str, str]:
+    """Return a mapping from namespace URI to standard prefix name.
+
+    Uses rdflib's curated default namespace bindings as the source of truth.
+    For example, ``https://schema.org/`` maps to ``schema``.
+
+    This allows generators to normalise non-standard prefix aliases
+    (e.g. ``sdo`` for ``https://schema.org/``) to their conventional names.
+    """
+    from rdflib import Graph as RdfGraph
+
+    return {str(ns): str(pfx) for pfx, ns in RdfGraph().namespaces() if str(pfx)}
+
+

diffable_rdf-0.0.1/tests/test_diffable_rdf.py

@@ -0,0 +1,132 @@
+"""Tests for the diffable-rdf public API."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from rdflib import BNode, Graph, Literal, Namespace, URIRef
+from rdflib.compare import isomorphic
+from rdflib.namespace import RDF, RDFS, XSD
+
+from diffable_rdf import (
+    canonicalize_rdf_graph,
+    deterministic_json,
+    deterministic_turtle,
+    well_known_prefix_map,
+)
+
+EX = Namespace("http://example.org/")
+
+
+def _sample_graph() -> Graph:
+    g = Graph()
+    g.bind("ex", EX)
+    g.bind("rdfs", RDFS)
+    # a class with two restriction-like blank nodes
+    cls = EX.Thing
+    g.add((cls, RDF.type, RDFS.Class))
+    g.add((cls, RDFS.label, Literal("Thing", lang="en")))
+    g.add((cls, RDFS.comment, Literal("a plain string literal")))
+    for name, dt in (("width", XSD.double), ("count", XSD.integer)):
+        b = BNode()
+        g.add((cls, EX.constraint, b))
+        g.add((b, EX.onProperty, EX[name]))
+        g.add((b, EX.datatype, dt))
+    return g
+
+
+def test_deterministic_turtle_is_byte_stable_across_runs():
+    g = _sample_graph()
+    out1 = deterministic_turtle(g)
+    out2 = deterministic_turtle(_sample_graph())
+    assert out1 == out2
+
+
+def test_deterministic_turtle_is_isomorphic_to_input():
+    g = _sample_graph()
+    out = deterministic_turtle(g)
+    round_trip = Graph().parse(data=out, format="turtle")
+    assert isomorphic(round_trip, g)
+
+
+def test_deterministic_turtle_strips_xsd_string():
+    g = Graph()
+    g.add((EX.s, EX.p, Literal("plain", datatype=XSD.string)))
+    out = deterministic_turtle(g)
+    assert "xsd:string" not in out
+    assert "^^" not in out
+
+
+def test_deterministic_turtle_uses_inline_blank_nodes():
+    g = _sample_graph()
+    out = deterministic_turtle(g)
+    assert "[" in out and "]" in out
+
+
+def test_deterministic_turtle_filters_unused_prefixes():
+    g = _sample_graph()
+    out = deterministic_turtle(g)
+    # rdflib binds ~27 default prefixes; only referenced ones should appear
+    assert "@prefix brick:" not in out
+    assert "@prefix ex:" in out
+
+
+def test_deterministic_turtle_no_bnodes():
+    g = Graph()
+    g.bind("ex", EX)
+    g.add((EX.a, EX.p, EX.b))
+    out1 = deterministic_turtle(g)
+    out2 = deterministic_turtle(g)
+    assert out1 == out2
+    assert isomorphic(Graph().parse(data=out1, format="turtle"), g)
+
+
+def test_wl_stable_when_unrelated_triple_added():
+    g1 = _sample_graph()
+    g2 = _sample_graph()
+    g2.add((EX.Unrelated, RDF.type, RDFS.Class))
+    out1 = deterministic_turtle(g1)
+    out2 = deterministic_turtle(g2)
+    # the added statement must appear; the shared block's bnode labels
+    # (b<hash>) that survive should keep output overwhelmingly shared.
+    assert out1 != out2
+    shared = set(out1.splitlines()) & set(out2.splitlines())
+    assert len(shared) >= len(out1.splitlines()) // 2
+
+
+def test_deterministic_json_sorts_keys_and_lists():
+    obj = {"b": 1, "a": [3, 1, 2], "c": {"z": 0, "y": 1}}
+    out = deterministic_json(obj)
+    parsed = json.loads(out)
+    assert list(parsed.keys()) == ["a", "b", "c"]
+    assert parsed["a"] == [1, 2, 3]
+    assert list(parsed["c"].keys()) == ["y", "z"]
+
+
+def test_deterministic_json_preserves_context_order():
+    obj = {"@context": ["z", "a", "m"], "x": 1}
+    out = deterministic_json(obj)
+    parsed = json.loads(out)
+    assert parsed["@context"] == ["z", "a", "m"]
+
+
+def test_canonicalize_rdf_graph_is_deterministic():
+    g = _sample_graph()
+    out1 = canonicalize_rdf_graph(g, "turtle")
+    out2 = canonicalize_rdf_graph(_sample_graph(), "turtle")
+    assert out1 == out2
+    assert isomorphic(Graph().parse(data=out1, format="turtle"), g)
+
+
+def test_canonicalize_rdf_graph_falls_back_for_literal_predicates():
+    # A literal in predicate position is non-standard RDF; must not crash.
+    g = Graph()
+    g.add((EX.s, EX.p, EX.o))
+    out = canonicalize_rdf_graph(g, "turtle")
+    assert "http://example.org/p" in out
+
+
+def test_well_known_prefix_map_contains_schema_org():
+    m = well_known_prefix_map()
+    assert m.get("https://schema.org/") == "schema"