rdf-construct 0.3.0__py3-none-any.whl

rdf_construct/refactor/formatters/text.py

@@ -0,0 +1,311 @@
+"""Text formatter for refactor command output.
+
+Provides formatted output for dry-run previews and results.
+"""
+
+from typing import Any
+
+from rdf_construct.refactor.config import RenameConfig, RenameMapping, DeprecationSpec
+from rdf_construct.refactor.renamer import RenameResult, RenameStats
+from rdf_construct.refactor.deprecator import DeprecationResult, EntityDeprecationInfo
+
+
+class TextFormatter:
+    """Text formatter for refactor results and previews.
+
+    Attributes:
+        use_colour: Whether to use ANSI colour codes.
+    """
+
+    def __init__(self, use_colour: bool = True):
+        """Initialize formatter.
+
+        Args:
+            use_colour: Whether to use ANSI colour codes.
+        """
+        self.use_colour = use_colour
+
+    def _colour(self, text: str, colour: str) -> str:
+        """Apply ANSI colour code if enabled.
+
+        Args:
+            text: Text to colour.
+            colour: Colour name (green, red, yellow, cyan, bold).
+
+        Returns:
+            Coloured text (or original if colour disabled).
+        """
+        if not self.use_colour:
+            return text
+
+        codes = {
+            "green": "\033[32m",
+            "red": "\033[31m",
+            "yellow": "\033[33m",
+            "cyan": "\033[36m",
+            "bold": "\033[1m",
+            "dim": "\033[2m",
+            "reset": "\033[0m",
+        }
+        return f"{codes.get(colour, '')}{text}{codes['reset']}"
+
+    def format_rename_preview(
+        self,
+        mappings: list[RenameMapping],
+        source_file: str,
+        source_triples: int,
+        literal_mentions: dict[str, int] | None = None,
+    ) -> str:
+        """Format a dry-run preview for rename operation.
+
+        Args:
+            mappings: List of rename mappings to apply.
+            source_file: Name of source file.
+            source_triples: Number of triples in source.
+            literal_mentions: Count of mentions in literals (won't be changed).
+
+        Returns:
+            Formatted preview string.
+        """
+        lines = [
+            self._colour("Refactoring Preview: Rename", "bold"),
+            "=" * 27,
+            "",
+            f"Source: {source_file} ({source_triples:,} triples)",
+            "",
+        ]
+
+        # Group by source type
+        namespace_mappings = [m for m in mappings if m.source == "namespace"]
+        explicit_mappings = [m for m in mappings if m.source == "explicit"]
+
+        if namespace_mappings:
+            # Group by namespace
+            namespaces: dict[str, list[RenameMapping]] = {}
+            for m in namespace_mappings:
+                # Extract namespace prefix
+                from_str = str(m.from_uri)
+                to_str = str(m.to_uri)
+                # Find common prefix
+                ns_from = from_str.rsplit("#", 1)[0] + "#" if "#" in from_str else from_str.rsplit("/", 1)[0] + "/"
+                ns_to = to_str.rsplit("#", 1)[0] + "#" if "#" in to_str else to_str.rsplit("/", 1)[0] + "/"
+                key = f"{ns_from} → {ns_to}"
+                if key not in namespaces:
+                    namespaces[key] = []
+                namespaces[key].append(m)
+
+            lines.append(self._colour("Namespace renames:", "cyan"))
+            for ns_change, ns_mappings in namespaces.items():
+                lines.append(f"  {ns_change}")
+                lines.append(f"    - {len(ns_mappings)} entities affected")
+            lines.append("")
+
+        if explicit_mappings:
+            lines.append(self._colour("Entity renames:", "cyan"))
+            for m in explicit_mappings:
+                from_local = str(m.from_uri).split("#")[-1].split("/")[-1]
+                to_local = str(m.to_uri).split("#")[-1].split("/")[-1]
+                lines.append(f"  {from_local} → {to_local}")
+
+                # Check for literal mentions
+                if literal_mentions and str(m.from_uri) in literal_mentions:
+                    count = literal_mentions[str(m.from_uri)]
+                    lines.append(
+                        f"    └─ {count} literal mention(s) "
+                        f"{self._colour('(NOT changed)', 'yellow')}"
+                    )
+            lines.append("")
+
+        # Summary
+        lines.append(self._colour("Totals:", "bold"))
+        lines.append(f"  - {len(mappings)} entities to rename")
+        if namespace_mappings:
+            lines.append(f"  - {len(namespace_mappings)} from namespace rules")
+        if explicit_mappings:
+            lines.append(f"  - {len(explicit_mappings)} from explicit rules")
+        lines.append("")
+        lines.append(self._colour("Run without --dry-run to apply changes.", "dim"))
+
+        return "\n".join(lines)
+
+    def format_rename_result(self, result: RenameResult) -> str:
+        """Format the result of a rename operation.
+
+        Args:
+            result: Result from rename operation.
+
+        Returns:
+            Formatted result string.
+        """
+        if not result.success:
+            return self._colour(f"✗ Rename failed: {result.error}", "red")
+
+        lines = [
+            self._colour("Rename Complete", "green"),
+            "",
+            f"  Source triples: {result.source_triples:,}",
+            f"  Result triples: {result.result_triples:,}",
+            "",
+            self._colour("Changes:", "cyan"),
+            f"  - Subjects renamed: {result.stats.subjects_renamed:,}",
+            f"  - Predicates renamed: {result.stats.predicates_renamed:,}",
+            f"  - Objects renamed: {result.stats.objects_renamed:,}",
+            f"  - Total URI substitutions: {result.stats.total_renames:,}",
+        ]
+
+        if result.stats.namespace_entities > 0:
+            lines.append(f"  - Via namespace rules: {result.stats.namespace_entities:,}")
+        if result.stats.explicit_entities > 0:
+            lines.append(f"  - Via explicit rules: {result.stats.explicit_entities:,}")
+
+        if result.stats.literal_mentions:
+            lines.append("")
+            lines.append(
+                self._colour(
+                    f"  ⚠ {len(result.stats.literal_mentions)} entities mentioned in literals "
+                    "(not modified)",
+                    "yellow",
+                )
+            )
+
+        return "\n".join(lines)
+
+    def format_deprecation_preview(
+        self,
+        specs: list[DeprecationSpec],
+        entity_info: list[EntityDeprecationInfo] | None = None,
+        source_file: str = "",
+        source_triples: int = 0,
+    ) -> str:
+        """Format a dry-run preview for deprecation operation.
+
+        Args:
+            specs: List of deprecation specifications.
+            entity_info: Optional entity information from dry run.
+            source_file: Name of source file.
+            source_triples: Number of triples in source.
+
+        Returns:
+            Formatted preview string.
+        """
+        lines = [
+            self._colour("Refactoring Preview: Deprecate", "bold"),
+            "=" * 30,
+            "",
+            f"Source: {source_file} ({source_triples:,} triples)" if source_file else "",
+            "",
+            self._colour("Entities to deprecate:", "cyan"),
+            "",
+        ]
+
+        for i, spec in enumerate(specs):
+            # Extract local name
+            local_name = spec.entity.split("#")[-1].split("/")[-1]
+            lines.append(f"  {self._colour(local_name, 'bold')}")
+
+            # Show current state if available
+            if entity_info and i < len(entity_info):
+                info = entity_info[i]
+                if not info.found:
+                    lines.append(f"    {self._colour('⚠ Entity not found in graph', 'yellow')}")
+                else:
+                    if info.was_already_deprecated:
+                        lines.append(f"    {self._colour('Already deprecated', 'yellow')}")
+                    if info.current_labels:
+                        lines.append(f"    rdfs:label: \"{info.current_labels[0]}\"")
+                    if info.reference_count > 0:
+                        lines.append(
+                            f"    {self._colour(f'Referenced {info.reference_count} times', 'dim')}"
+                        )
+
+            # Show what will be added
+            lines.append("    Will add:")
+            lines.append(f"      owl:deprecated {self._colour('true', 'green')}")
+
+            if spec.replaced_by:
+                repl_local = spec.replaced_by.split("#")[-1].split("/")[-1]
+                lines.append(f"      dcterms:isReplacedBy {self._colour(repl_local, 'cyan')}")
+
+            if spec.message:
+                msg_preview = spec.message[:50] + "..." if len(spec.message) > 50 else spec.message
+                lines.append(f"      rdfs:comment \"DEPRECATED: {msg_preview}\"")
+
+            lines.append("")
+
+        # Summary
+        lines.append(self._colour("Summary:", "bold"))
+        lines.append(f"  - {len(specs)} entities will be marked deprecated")
+        with_replacement = len([s for s in specs if s.replaced_by])
+        lines.append(f"  - {with_replacement} with replacement")
+        lines.append(f"  - {len(specs) - with_replacement} without replacement")
+        lines.append("")
+        lines.append(
+            self._colour(
+                "Note: Deprecation marks entities but does not rename or migrate.",
+                "dim",
+            )
+        )
+        lines.append(
+            self._colour(
+                "      Use 'refactor rename' to actually migrate references.",
+                "dim",
+            )
+        )
+        lines.append("")
+        lines.append(self._colour("Run without --dry-run to apply changes.", "dim"))
+
+        return "\n".join(lines)
+
+    def format_deprecation_result(self, result: DeprecationResult) -> str:
+        """Format the result of a deprecation operation.
+
+        Args:
+            result: Result from deprecation operation.
+
+        Returns:
+            Formatted result string.
+        """
+        if not result.success:
+            return self._colour(f"✗ Deprecation failed: {result.error}", "red")
+
+        lines = [
+            self._colour("Deprecation Complete", "green"),
+            "",
+            f"  Source triples: {result.source_triples:,}",
+            f"  Result triples: {result.result_triples:,}",
+            "",
+            self._colour("Changes:", "cyan"),
+            f"  - Entities deprecated: {result.stats.entities_deprecated}",
+            f"  - Triples added: {result.stats.triples_added}",
+        ]
+
+        if result.stats.entities_not_found > 0:
+            lines.append(
+                self._colour(
+                    f"  ⚠ Entities not found: {result.stats.entities_not_found}",
+                    "yellow",
+                )
+            )
+
+        if result.stats.entities_already_deprecated > 0:
+            lines.append(
+                f"  - Already deprecated: {result.stats.entities_already_deprecated}"
+            )
+
+        # Show details of deprecated entities
+        if result.entity_info:
+            lines.append("")
+            lines.append("Details:")
+            for info in result.entity_info:
+                local_name = info.uri.split("#")[-1].split("/")[-1]
+                if not info.found:
+                    lines.append(f"  {self._colour('⚠', 'yellow')} {local_name} - not found")
+                elif info.was_already_deprecated and info.triples_added == 0:
+                    lines.append(f"  ○ {local_name} - already deprecated, no changes")
+                else:
+                    lines.append(f"  {self._colour('✓', 'green')} {local_name}")
+                    if info.replaced_by:
+                        repl_local = info.replaced_by.split("#")[-1].split("/")[-1]
+                        lines.append(f"      → replaced by {repl_local}")
+
+        return "\n".join(lines)

rdf_construct/refactor/renamer.py

@@ -0,0 +1,294 @@
+"""URI renaming logic for ontology refactoring.
+
+This module handles renaming URIs in RDF graphs:
+- Single entity renames (fixing typos, etc.)
+- Bulk namespace changes (project/org renames)
+- Predicate position handling (URIs as predicates are also renamed)
+
+The renamer does NOT modify text inside literals - comments mentioning
+renamed entities are left unchanged (this is intentional to avoid
+corrupting documentation).
+"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from rdflib import Graph, URIRef, Literal, BNode
+
+from rdf_construct.refactor.config import RenameConfig, RenameMapping
+
+
+@dataclass
+class RenameStats:
+    """Statistics from a rename operation.
+
+    Attributes:
+        subjects_renamed: URIs renamed in subject position.
+        predicates_renamed: URIs renamed in predicate position.
+        objects_renamed: URIs renamed in object position.
+        entities_by_source: Count of entities by mapping source.
+        literal_mentions: Count of mentions in literals (NOT renamed).
+    """
+
+    subjects_renamed: int = 0
+    predicates_renamed: int = 0
+    objects_renamed: int = 0
+    entities_by_source: dict[str, int] = field(default_factory=dict)
+    literal_mentions: dict[str, int] = field(default_factory=dict)
+
+    @property
+    def total_renames(self) -> int:
+        """Total number of URI substitutions made."""
+        return self.subjects_renamed + self.predicates_renamed + self.objects_renamed
+
+    @property
+    def namespace_entities(self) -> int:
+        """Number of entities renamed by namespace rules."""
+        return self.entities_by_source.get("namespace", 0)
+
+    @property
+    def explicit_entities(self) -> int:
+        """Number of entities renamed by explicit rules."""
+        return self.entities_by_source.get("explicit", 0)
+
+
+@dataclass
+class RenameResult:
+    """Result of a rename operation.
+
+    Attributes:
+        renamed_graph: The graph with URIs renamed.
+        stats: Rename statistics.
+        success: Whether the operation succeeded.
+        error: Error message if success is False.
+        mappings_applied: List of mappings that were actually applied.
+        source_triples: Original triple count.
+        result_triples: Final triple count.
+    """
+
+    renamed_graph: Graph | None = None
+    stats: RenameStats = field(default_factory=RenameStats)
+    success: bool = True
+    error: str | None = None
+    mappings_applied: list[RenameMapping] = field(default_factory=list)
+    source_triples: int = 0
+    result_triples: int = 0
+
+
+class OntologyRenamer:
+    """Renames URIs in RDF ontology graphs.
+
+    Handles both single entity renames and bulk namespace changes.
+    The renamer processes subjects, predicates, and objects, but
+    intentionally leaves literal values unchanged.
+
+    Example usage:
+        renamer = OntologyRenamer()
+        config = RenameConfig(entities={
+            "http://example.org/Buiding": "http://example.org/Building"
+        })
+        result = renamer.rename(graph, config)
+    """
+
+    def rename(
+        self,
+        graph: Graph,
+        config: RenameConfig,
+    ) -> RenameResult:
+        """Rename URIs in a graph according to configuration.
+
+        Args:
+            graph: Source RDF graph.
+            config: Rename configuration with namespace and entity mappings.
+
+        Returns:
+            RenameResult with the modified graph and statistics.
+        """
+        result = RenameResult()
+        result.source_triples = len(graph)
+
+        # Build concrete mappings from config
+        mappings = config.build_mappings(graph)
+        if not mappings:
+            # Nothing to rename
+            result.renamed_graph = graph
+            result.result_triples = len(graph)
+            return result
+
+        # Create URI lookup map for efficient substitution
+        uri_map: dict[URIRef, tuple[URIRef, str]] = {
+            m.from_uri: (m.to_uri, m.source) for m in mappings
+        }
+
+        # Track which mappings were actually applied
+        applied_mappings: set[URIRef] = set()
+
+        # Create new graph with renamed URIs
+        renamed_graph = Graph()
+
+        # Copy namespace bindings, updating if needed
+        old_ns_to_new: dict[str, str] = {}
+        if config.namespaces:
+            old_ns_to_new = config.namespaces
+
+        for prefix, ns in graph.namespace_manager.namespaces():
+            ns_str = str(ns)
+            new_ns_str = ns_str
+            for old_ns, new_ns in old_ns_to_new.items():
+                if ns_str.startswith(old_ns) or ns_str == old_ns:
+                    new_ns_str = ns_str.replace(old_ns, new_ns, 1)
+                    break
+            renamed_graph.bind(prefix, new_ns_str, override=True)
+
+        # Process each triple
+        for s, p, o in graph:
+            new_s, new_p, new_o = s, p, o
+
+            # Check subject
+            if isinstance(s, URIRef) and s in uri_map:
+                new_s = uri_map[s][0]
+                result.stats.subjects_renamed += 1
+                applied_mappings.add(s)
+                source = uri_map[s][1]
+                result.stats.entities_by_source[source] = (
+                    result.stats.entities_by_source.get(source, 0) + 1
+                )
+
+            # Check predicate
+            if isinstance(p, URIRef) and p in uri_map:
+                new_p = uri_map[p][0]
+                result.stats.predicates_renamed += 1
+                applied_mappings.add(p)
+                # Don't double-count in entities_by_source
+
+            # Check object (only URIRefs, not Literals)
+            if isinstance(o, URIRef) and o in uri_map:
+                new_o = uri_map[o][0]
+                result.stats.objects_renamed += 1
+                applied_mappings.add(o)
+                # Don't double-count in entities_by_source
+
+            renamed_graph.add((new_s, new_p, new_o))
+
+        # Scan for literal mentions (informational only)
+        for mapping in mappings:
+            old_local = str(mapping.from_uri).split("#")[-1].split("/")[-1]
+            for s, p, o in graph:
+                if isinstance(o, Literal) and old_local in str(o):
+                    key = str(mapping.from_uri)
+                    result.stats.literal_mentions[key] = (
+                        result.stats.literal_mentions.get(key, 0) + 1
+                    )
+
+        # Build list of applied mappings
+        result.mappings_applied = [m for m in mappings if m.from_uri in applied_mappings]
+
+        result.renamed_graph = renamed_graph
+        result.result_triples = len(renamed_graph)
+        result.success = True
+
+        return result
+
+    def rename_single(
+        self,
+        graph: Graph,
+        from_uri: str,
+        to_uri: str,
+    ) -> RenameResult:
+        """Convenience method for renaming a single URI.
+
+        Args:
+            graph: Source RDF graph.
+            from_uri: URI to rename.
+            to_uri: New URI.
+
+        Returns:
+            RenameResult with the modified graph.
+        """
+        config = RenameConfig(entities={from_uri: to_uri})
+        return self.rename(graph, config)
+
+    def rename_namespace(
+        self,
+        graph: Graph,
+        from_namespace: str,
+        to_namespace: str,
+    ) -> RenameResult:
+        """Convenience method for bulk namespace rename.
+
+        Args:
+            graph: Source RDF graph.
+            from_namespace: Old namespace prefix.
+            to_namespace: New namespace prefix.
+
+        Returns:
+            RenameResult with the modified graph.
+        """
+        config = RenameConfig(namespaces={from_namespace: to_namespace})
+        return self.rename(graph, config)
+
+
+def rename_file(
+    source_path: Path,
+    output_path: Path,
+    config: RenameConfig,
+) -> RenameResult:
+    """Convenience function to rename URIs in a file.
+
+    Args:
+        source_path: Path to source RDF file.
+        output_path: Path to write renamed output.
+        config: Rename configuration.
+
+    Returns:
+        RenameResult with statistics.
+    """
+    # Load source graph
+    graph = Graph()
+    try:
+        graph.parse(source_path.as_posix())
+    except Exception as e:
+        result = RenameResult()
+        result.success = False
+        result.error = f"Failed to parse {source_path}: {e}"
+        return result
+
+    # Perform rename
+    renamer = OntologyRenamer()
+    result = renamer.rename(graph, config)
+
+    if not result.success:
+        return result
+
+    # Write output
+    if result.renamed_graph:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        result.renamed_graph.serialize(destination=output_path.as_posix(), format="turtle")
+
+    return result
+
+
+def rename_files(
+    source_paths: list[Path],
+    output_dir: Path,
+    config: RenameConfig,
+) -> list[tuple[Path, RenameResult]]:
+    """Rename URIs in multiple files.
+
+    Args:
+        source_paths: Paths to source RDF files.
+        output_dir: Directory to write renamed outputs.
+        config: Rename configuration.
+
+    Returns:
+        List of (output_path, result) tuples.
+    """
+    results: list[tuple[Path, RenameResult]] = []
+
+    for source_path in source_paths:
+        output_path = output_dir / source_path.name
+        result = rename_file(source_path, output_path, config)
+        results.append((output_path, result))
+
+    return results

rdf_construct/shacl/__init__.py

@@ -0,0 +1,56 @@
+"""SHACL shape generation from OWL ontologies.
+
+This module provides tools for generating SHACL validation shapes from
+OWL ontology definitions, converting domain/range, cardinality restrictions,
+and other OWL patterns to equivalent SHACL constraints.
+
+Basic usage:
+
+    from rdf_construct.shacl import generate_shapes, ShaclConfig, StrictnessLevel
+
+    # Generate shapes with default settings
+    graph, turtle = generate_shapes(Path("ontology.ttl"))
+
+    # Generate with strict level
+    config = ShaclConfig(level=StrictnessLevel.STRICT, closed=True)
+    graph, turtle = generate_shapes(Path("ontology.ttl"), config)
+
+    # Generate and write to file
+    from rdf_construct.shacl import generate_shapes_to_file
+    generate_shapes_to_file(
+        Path("ontology.ttl"),
+        Path("shapes.ttl"),
+        config,
+    )
+"""
+
+from rdf_construct.shacl.config import (
+    ShaclConfig,
+    Severity,
+    StrictnessLevel,
+    load_shacl_config,
+)
+from rdf_construct.shacl.converters import PropertyConstraint
+from rdf_construct.shacl.generator import (
+    ShapeGenerator,
+    generate_shapes,
+    generate_shapes_to_file,
+)
+from rdf_construct.shacl.namespaces import SH, SHACL_PREFIXES
+
+__all__ = [
+    # Configuration
+    "ShaclConfig",
+    "StrictnessLevel",
+    "Severity",
+    "load_shacl_config",
+    # Generator
+    "ShapeGenerator",
+    "generate_shapes",
+    "generate_shapes_to_file",
+    # Converters
+    "PropertyConstraint",
+    # Namespaces
+    "SH",
+    "SHACL_PREFIXES",
+]