rdf-construct 0.4.1__tar.gz → 0.4.2__tar.gz

{rdf_construct-0.4.1 → rdf_construct-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdf-construct
-Version: 0.4.1
+Version: 0.4.2
 Summary: Semantic RDF manipulation toolkit - order, serialize, and diff RDF ontologies
 License-Expression: MIT
 License-File: LICENSE

{rdf_construct-0.4.1 → rdf_construct-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "rdf-construct"
-version = "0.4.1"
+version = "0.4.2"
 description = "Semantic RDF manipulation toolkit - order, serialize, and diff RDF ontologies"
 license = "MIT"
 readme = "README.md"

{rdf_construct-0.4.1 → rdf_construct-0.4.2}/src/rdf_construct/__init__.py

@@ -4,7 +4,7 @@ Named after the ROM construct from William Gibson's Neuromancer -
 preserved, structured knowledge that can be queried and transformed.
 """
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 
 from . import core, uml
 from .cli import cli

{rdf_construct-0.4.1 → rdf_construct-0.4.2}/src/rdf_construct/core/__init__.py

@@ -3,7 +3,7 @@
 from .ordering import sort_subjects, topo_sort_subset, sort_with_roots
 from .profile import OrderingConfig, OrderingProfile, load_yaml
 from .selector import select_subjects
-from .serialiser import serialise_turtle, build_section_graph
+from .serialiser import collect_used_namespaces, serialise_turtle, build_section_graph
 from .utils import (
     expand_curie,
     extract_prefix_map,
@@ -23,6 +23,7 @@ __all__ = [
     # Selector
     "select_subjects",
     # Serialiser
+    "collect_used_namespaces",
     "serialise_turtle",
     "build_section_graph",
     # Utils
@@ -30,4 +31,4 @@ __all__ = [
     "extract_prefix_map",
     "qname_sort_key",
     "rebind_prefixes",
-]
+]

{rdf_construct-0.4.1 → rdf_construct-0.4.2}/src/rdf_construct/core/serialiser.py

@@ -26,6 +26,54 @@ except ImportError:
     )
 
 
+def collect_used_namespaces(
+    graph: Graph,
+    namespace_source: Graph | None = None,
+) -> set[str]:
+    """Collect namespace URIs that are actually used in the graph's triples.
+
+    Scans all subjects, predicates, and objects (including Literal datatype
+    URIs) to find which registered namespace URIs are referenced. Uses
+    longest-match-first ordering to correctly handle overlapping namespaces
+    (e.g. ``dc:`` vs ``dcterms:``).
+
+    Args:
+        graph: RDF graph whose triples to scan.
+        namespace_source: Optional graph whose namespace registry to match
+            against. Defaults to *graph* itself. Use this when the graph
+            being scanned has a stripped namespace manager (e.g. built
+            with ``bind_namespaces="none"``).
+
+    Returns:
+        Set of namespace URI strings that appear in the graph's triples.
+    """
+    ns_graph = namespace_source if namespace_source is not None else graph
+
+    used_ns: set[str] = set()
+    # Sort namespaces longest-first so we match the most specific prefix
+    ns_uris = sorted(
+        [str(uri) for _, uri in ns_graph.namespace_manager.namespaces()],
+        key=len,
+        reverse=True,
+    )
+
+    def _match_uri(uri_str: str) -> None:
+        """Add the best-matching namespace for *uri_str* to used_ns."""
+        for ns_uri in ns_uris:
+            if uri_str.startswith(ns_uri):
+                used_ns.add(ns_uri)
+                return
+
+    for s, p, o in graph:
+        for term in (s, p, o):
+            if isinstance(term, URIRef):
+                _match_uri(str(term))
+            elif isinstance(term, Literal) and term.datatype is not None:
+                _match_uri(str(term.datatype))
+
+    return used_ns
+
+
 def format_term(graph: Graph, term, use_prefixes: bool = True) -> str:
     """Format an RDF term as a Turtle string.
 
@@ -79,8 +127,11 @@ def serialise_turtle(
     This custom serialiser respects the exact order of subjects provided,
     unlike rdflib's built-in serialisers which always sort alphabetically.
 
+    Only prefix declarations for namespaces actually used in the graph's
+    triples are emitted, filtering out rdflib's built-in defaults.
+
     Formatting features:
-    - Prefixes sorted alphabetically at top
+    - Prefixes sorted alphabetically at top (used namespaces only)
     - Subjects in specified order
     - rdf:type predicate listed first for each subject
     - Predicates ordered according to predicate_order config (or alphabetically)
@@ -95,10 +146,11 @@ def serialise_turtle(
     """
     lines = []
 
-    # Write prefixes
+    # Write prefixes — only those actually used in the graph
+    used_ns = collect_used_namespaces(graph)
     prefixes = sorted(graph.namespace_manager.namespaces(), key=lambda x: x[0])
     for prefix, namespace in prefixes:
-        if prefix:  # Skip the default namespace
+        if prefix and str(namespace) in used_ns:
             lines.append(f"PREFIX {prefix}: <{namespace}>")
     lines.append("")  # Blank line after prefixes
 
@@ -208,8 +260,9 @@ def build_section_graph(base: Graph, subjects_ordered: list) -> Graph:
     """Build a new graph containing only the specified subjects and their triples.
 
     Creates a filtered view of the base graph that includes all triples
-    where the subject is in the provided list. Preserves all namespace
-    bindings from the base graph.
+    where the subject is in the provided list. Only namespace bindings
+    that are actually used by the included triples are carried over;
+    rdflib's built-in well-known namespace defaults are suppressed.
 
     Args:
         base: Source RDF graph to filter
@@ -218,15 +271,20 @@ def build_section_graph(base: Graph, subjects_ordered: list) -> Graph:
     Returns:
         New graph containing only triples for the specified subjects
     """
-    sg = Graph()
-
-    # Copy namespace bindings
-    for pfx, uri in base.namespace_manager.namespaces():
-        sg.namespace_manager.bind(pfx, uri, override=True, replace=True)
+    # Suppress rdflib's automatic well-known namespace bindings so the
+    # sub-graph starts with a clean namespace manager.
+    sg = Graph(bind_namespaces="none")
 
     # Copy triples for each subject
     for s in subjects_ordered:
         for p, o in base.predicate_objects(s):
             sg.add((s, p, o))
 
+    # Match sub-graph triples against the *base* graph's namespace registry
+    # (the sub-graph's own registry is intentionally empty at this point).
+    used_ns = collect_used_namespaces(sg, namespace_source=base)
+    for pfx, uri in base.namespace_manager.namespaces():
+        if str(uri) in used_ns:
+            sg.namespace_manager.bind(pfx, uri, override=True, replace=True)
+
     return sg