sutradb 0.3.2__py2.py3-none-any.whl

sutradb/__init__.py

@@ -0,0 +1,5 @@
+from .client import SutraClient
+from .owl import OWLValidator, OWLViolation
+
+__version__ = "0.1.0"
+__all__ = ["SutraClient", "OWLValidator", "OWLViolation"]

sutradb/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.2"

sutradb/client.py

@@ -0,0 +1,285 @@
+"""SutraDB Python client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+
+class SutraError(Exception):
+    """Exception raised by the SutraDB client on request failures."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class SutraClient:
+    """Client for interacting with a SutraDB server.
+
+    Args:
+        endpoint: Base URL of the SutraDB HTTP server.
+            Defaults to ``http://localhost:3030``.
+        owl_validation: Enable client-side OWL constraint validation.
+            When True (default), inserts are checked against OWL axioms
+            stored in the database before being sent. Raises OWLViolation
+            on constraint violations. The database itself always accepts
+            all triples regardless of this setting.
+    """
+
+    def __init__(
+        self,
+        endpoint: str = "http://localhost:3030",
+        owl_validation: bool = True,
+    ) -> None:
+        self.endpoint = endpoint.rstrip("/")
+        self._session = requests.Session()
+        self._session.headers.update({"User-Agent": "sutradb-python/0.1.0"})
+        self._owl_validation = owl_validation
+        self._owl_validator = None
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _url(self, path: str) -> str:
+        return f"{self.endpoint}{path}"
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any | None = None,
+        data: str | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> requests.Response:
+        """Send an HTTP request and raise :class:`SutraError` on failure."""
+        try:
+            resp = self._session.request(
+                method,
+                self._url(path),
+                params=params,
+                json=json,
+                data=data,
+                headers=headers,
+            )
+        except requests.RequestException as exc:
+            raise SutraError(f"Connection error: {exc}") from exc
+
+        if not resp.ok:
+            raise SutraError(
+                f"HTTP {resp.status_code}: {resp.text}",
+                status_code=resp.status_code,
+            )
+        return resp
+
+    # ------------------------------------------------------------------
+    # OWL validation
+    # ------------------------------------------------------------------
+
+    def _ensure_owl_loaded(self) -> None:
+        """Lazy-load OWL ontology from the database on first validation."""
+        if self._owl_validator is not None:
+            return
+        try:
+            from .owl import OWLValidator
+
+            self._owl_validator = OWLValidator()
+            self._owl_validator.load_from_client(self)
+        except Exception:
+            # If we can't load the ontology, skip validation silently
+            self._owl_validator = None
+
+    def reload_owl(self) -> None:
+        """Force reload of OWL ontology from the database."""
+        self._owl_validator = None
+        self._ensure_owl_loaded()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def health(self) -> bool:
+        """Check whether the server is reachable.
+
+        Returns:
+            ``True`` if the server responds to ``GET /health`` with a 2xx
+            status code, ``False`` otherwise.
+        """
+        try:
+            self._request("GET", "/health")
+            return True
+        except SutraError:
+            return False
+
+    def sparql(self, query: str) -> dict:
+        """Execute a SPARQL query and return the parsed JSON result.
+
+        Args:
+            query: A SPARQL 1.1 query string.
+
+        Returns:
+            The JSON response body as a Python dict (SPARQL JSON Results
+            format for SELECT/ASK, or a status dict for UPDATE).
+
+        Raises:
+            SutraError: If the server returns a non-2xx status code.
+        """
+        resp = self._request(
+            "GET",
+            "/sparql",
+            params={"query": query},
+            headers={"Accept": "application/sparql-results+json"},
+        )
+        return resp.json()
+
+    def insert_triples(
+        self, ntriples: str, batch_size: int = 5000
+    ) -> dict[str, Any]:
+        """Insert triples in N-Triples format, optionally in batches.
+
+        Args:
+            ntriples: One or more triples in N-Triples syntax (one per line).
+            batch_size: Maximum number of triples to send per HTTP request.
+
+        Returns:
+            A dict ``{"inserted": int, "errors": list[str]}`` summarising the
+            outcome across all batches.
+        """
+        # OWL validation (client-side, before sending to database)
+        if self._owl_validation:
+            self._ensure_owl_loaded()
+            if self._owl_validator and self._owl_validator.has_constraints():
+                from .owl import OWLViolation
+
+                violations = self._owl_validator.validate_ntriples(ntriples)
+                if violations:
+                    raise violations[0]  # Raise first violation
+
+        lines = [
+            line for line in ntriples.splitlines() if line.strip()
+        ]
+
+        total_inserted = 0
+        errors: list[str] = []
+
+        for start in range(0, len(lines), batch_size):
+            batch = "\n".join(lines[start : start + batch_size])
+            try:
+                resp = self._request(
+                    "POST",
+                    "/triples",
+                    data=batch,
+                    headers={"Content-Type": "application/n-triples"},
+                )
+                body = resp.json()
+                total_inserted += body.get("inserted", 0)
+                batch_errors = body.get("errors", [])
+                if batch_errors:
+                    errors.extend(batch_errors)
+            except SutraError as exc:
+                errors.append(str(exc))
+
+        return {"inserted": total_inserted, "errors": errors}
+
+    def declare_vector(
+        self,
+        predicate: str,
+        dimensions: int,
+        m: int = 16,
+        ef_construction: int = 200,
+        metric: str = "cosine",
+    ) -> dict:
+        """Declare an HNSW-indexed vector predicate.
+
+        Args:
+            predicate: The IRI of the vector predicate (e.g.
+                ``"http://example.org/hasEmbedding"``).
+            dimensions: The fixed dimensionality of vectors for this predicate.
+            m: HNSW ``M`` parameter (max connections per node per layer).
+            ef_construction: HNSW ``ef_construction`` beam width.
+            metric: Distance metric (``"cosine"``, ``"euclidean"``, or
+                ``"dot"``).
+
+        Returns:
+            The server response as a dict, typically containing ``status`` and
+            ``predicate_id`` keys.
+
+        Raises:
+            SutraError: If the server rejects the declaration.
+        """
+        resp = self._request(
+            "POST",
+            "/vectors/declare",
+            json={
+                "predicate": predicate,
+                "dimensions": dimensions,
+                "m": m,
+                "ef_construction": ef_construction,
+                "metric": metric,
+            },
+        )
+        return resp.json()
+
+    def insert_vector(
+        self, predicate: str, subject: str, vector: list[float]
+    ) -> dict:
+        """Insert a single vector embedding.
+
+        Args:
+            predicate: The IRI of the vector predicate.
+            subject: The IRI of the subject node.
+            vector: The embedding as a list of floats.
+
+        Returns:
+            The server response as a dict, typically containing ``status`` and
+            ``triple_id`` keys.
+
+        Raises:
+            SutraError: If the server rejects the insert.
+        """
+        resp = self._request(
+            "POST",
+            "/vectors",
+            json={
+                "predicate": predicate,
+                "subject": subject,
+                "vector": vector,
+            },
+        )
+        return resp.json()
+
+    def insert_vectors_batch(
+        self,
+        predicate: str,
+        entries: list[tuple[str, list[float]]],
+        batch_size: int = 100,
+    ) -> dict[str, Any]:
+        """Insert multiple vectors in batches.
+
+        Args:
+            predicate: The IRI of the vector predicate.
+            entries: A list of ``(subject_iri, vector)`` tuples.
+            batch_size: Maximum number of vectors to send per HTTP request.
+
+        Returns:
+            A dict ``{"inserted": int, "errors": list[str]}`` summarising
+            the outcome across all batches.
+        """
+        total_inserted = 0
+        errors: list[str] = []
+
+        for start in range(0, len(entries), batch_size):
+            batch = entries[start : start + batch_size]
+            for subject, vector in batch:
+                try:
+                    result = self.insert_vector(predicate, subject, vector)
+                    if result.get("status") == "ok":
+                        total_inserted += 1
+                except SutraError as exc:
+                    errors.append(f"{subject}: {exc}")
+
+        return {"inserted": total_inserted, "errors": errors}

sutradb/jupyter.py

@@ -0,0 +1,124 @@
+"""Jupyter integration for SutraDB.
+
+Provides %%sparql cell magic for executing SPARQL queries inline in
+Jupyter notebooks with tabular result display.
+
+Usage in a Jupyter notebook:
+
+    # First, load the extension
+    %load_ext sutradb.jupyter
+
+    # Then use the magic
+    %%sparql
+    SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10
+
+    # Or with a custom endpoint
+    %%sparql http://localhost:8080
+    SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10
+"""
+
+from __future__ import annotations
+
+from IPython.core.magic import register_cell_magic, needs_local_scope
+import requests
+
+
+_default_endpoint = "http://localhost:3030"
+
+
+def _shorten(iri: str) -> str:
+    """Shorten an IRI for display."""
+    prefixes = {
+        "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf:",
+        "http://www.w3.org/2000/01/rdf-schema#": "rdfs:",
+        "http://www.w3.org/2002/07/owl#": "owl:",
+        "http://www.w3.org/2001/XMLSchema#": "xsd:",
+        "http://www.wikidata.org/entity/": "wd:",
+        "http://www.wikidata.org/prop/direct/": "wdt:",
+        "http://sutra.dev/": "sutra:",
+        "http://schema.org/": "schema:",
+    }
+    for full, short in prefixes.items():
+        if iri.startswith(full):
+            return short + iri[len(full):]
+    return iri
+
+
+@register_cell_magic
+def sparql(line, cell):
+    """Execute a SPARQL query against SutraDB.
+
+    Usage:
+        %%sparql [endpoint]
+        SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10
+    """
+    endpoint = line.strip() if line.strip() else _default_endpoint
+
+    try:
+        resp = requests.post(
+            f"{endpoint}/sparql",
+            data=cell,
+            headers={"Accept": "application/sparql-results+json"},
+            timeout=30,
+        )
+        if resp.status_code != 200:
+            print(f"Error: HTTP {resp.status_code}")
+            print(resp.text)
+            return
+
+        data = resp.json()
+        columns = data.get("head", {}).get("vars", [])
+        bindings = data.get("results", {}).get("bindings", [])
+
+        if not bindings:
+            print("No results.")
+            return
+
+        # Try to use pandas for nice display
+        try:
+            import pandas as pd
+
+            rows = []
+            for b in bindings:
+                row = {}
+                for col in columns:
+                    val = b.get(col, {}).get("value", "")
+                    row[col] = _shorten(val)
+                rows.append(row)
+            df = pd.DataFrame(rows, columns=columns)
+            from IPython.display import display
+
+            display(df)
+        except ImportError:
+            # Fallback: plain text table
+            # Header
+            widths = {c: max(len(c), 10) for c in columns}
+            for b in bindings[:20]:
+                for c in columns:
+                    v = _shorten(b.get(c, {}).get("value", ""))
+                    widths[c] = max(widths[c], min(len(v), 50))
+
+            header = " | ".join(c.ljust(widths[c]) for c in columns)
+            separator = "-+-".join("-" * widths[c] for c in columns)
+            print(header)
+            print(separator)
+            for b in bindings:
+                row = " | ".join(
+                    _shorten(b.get(c, {}).get("value", ""))[:widths[c]].ljust(
+                        widths[c]
+                    )
+                    for c in columns
+                )
+                print(row)
+            print(f"\n{len(bindings)} rows")
+
+    except requests.ConnectionError:
+        print(f"Error: Could not connect to SutraDB at {endpoint}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def load_ipython_extension(ipython):
+    """Called when %load_ext sutradb.jupyter is executed."""
+    # The @register_cell_magic decorator handles registration
+    pass

sutradb/langchain.py

@@ -0,0 +1,150 @@
+"""LangChain integration for SutraDB.
+
+Provides SutraDB as both a VectorStore and a knowledge graph for
+Retrieval-Augmented Generation (RAG) pipelines.
+
+Usage:
+    from sutradb.langchain import SutraVectorStore
+
+    vectorstore = SutraVectorStore(
+        endpoint="http://localhost:3030",
+        predicate="http://sutra.dev/hasEmbedding",
+    )
+
+    # Use with LangChain
+    retriever = vectorstore.as_retriever()
+    docs = retriever.get_relevant_documents("What is a transformer?")
+
+Requires: pip install langchain-core
+"""
+
+from __future__ import annotations
+
+from typing import Any, Iterable, Optional
+
+try:
+    from langchain_core.documents import Document
+    from langchain_core.vectorstores import VectorStore
+    from langchain_core.embeddings import Embeddings
+except ImportError:
+    raise ImportError(
+        "langchain-core is required for LangChain integration. "
+        "Install it with: pip install langchain-core"
+    )
+
+from .client import SutraClient
+
+
+class SutraVectorStore(VectorStore):
+    """LangChain VectorStore backed by SutraDB.
+
+    Uses SutraDB's HNSW vector index for similarity search and
+    the RDF triple store for metadata/knowledge graph queries.
+    """
+
+    def __init__(
+        self,
+        endpoint: str = "http://localhost:3030",
+        predicate: str = "http://sutra.dev/hasEmbedding",
+        embedding: Optional[Embeddings] = None,
+        dimensions: int = 1024,
+        **kwargs: Any,
+    ):
+        self._client = SutraClient(endpoint, owl_validation=False)
+        self._predicate = predicate
+        self._embedding = embedding
+        self._dimensions = dimensions
+
+        # Ensure vector predicate is declared
+        try:
+            self._client.declare_vector(predicate, dimensions)
+        except Exception:
+            pass  # May already exist
+
+    @property
+    def embeddings(self) -> Optional[Embeddings]:
+        return self._embedding
+
+    def add_texts(
+        self,
+        texts: Iterable[str],
+        metadatas: Optional[list[dict]] = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        """Add texts with embeddings to SutraDB."""
+        if self._embedding is None:
+            raise ValueError("Embeddings model required for add_texts")
+
+        texts_list = list(texts)
+        vectors = self._embedding.embed_documents(texts_list)
+        ids = []
+
+        for i, (text, vector) in enumerate(zip(texts_list, vectors)):
+            # Generate a subject IRI
+            import hashlib
+            text_hash = hashlib.md5(text.encode()).hexdigest()[:12]
+            subject = f"http://sutra.dev/doc/{text_hash}"
+
+            # Insert vector
+            self._client.insert_vector(self._predicate, subject, vector)
+
+            # Insert text as a triple
+            escaped = text.replace('"', '\\"').replace('\n', '\\n')
+            ntriples = f'<{subject}> <http://sutra.dev/text> "{escaped}" .'
+
+            # Insert metadata
+            if metadatas and i < len(metadatas):
+                for key, value in metadatas[i].items():
+                    escaped_val = str(value).replace('"', '\\"')
+                    ntriples += f'\n<{subject}> <http://sutra.dev/meta/{key}> "{escaped_val}" .'
+
+            self._client.insert_triples(ntriples)
+            ids.append(subject)
+
+        return ids
+
+    def similarity_search(
+        self,
+        query: str,
+        k: int = 4,
+        **kwargs: Any,
+    ) -> list[Document]:
+        """Search for similar documents."""
+        if self._embedding is None:
+            raise ValueError("Embeddings model required for similarity_search")
+
+        query_vector = self._embedding.embed_query(query)
+        vec_str = " ".join(f"{v:.6f}" for v in query_vector)
+
+        sparql = (
+            f'SELECT ?doc ?text WHERE {{\n'
+            f'  VECTOR_SIMILAR(?doc <{self._predicate}> '
+            f'"{vec_str}"^^<http://sutra.dev/f32vec>, 0.5, k:={k})\n'
+            f'  OPTIONAL {{ ?doc <http://sutra.dev/text> ?text }}\n'
+            f'}}'
+        )
+
+        result = self._client.sparql(sparql)
+        docs = []
+        for row in result.get("results", {}).get("bindings", []):
+            doc_uri = row.get("doc", {}).get("value", "")
+            text = row.get("text", {}).get("value", "")
+            docs.append(Document(
+                page_content=text or doc_uri,
+                metadata={"source": doc_uri},
+            ))
+
+        return docs
+
+    @classmethod
+    def from_texts(
+        cls,
+        texts: list[str],
+        embedding: Embeddings,
+        metadatas: Optional[list[dict]] = None,
+        **kwargs: Any,
+    ) -> "SutraVectorStore":
+        """Create a SutraVectorStore from texts."""
+        store = cls(embedding=embedding, **kwargs)
+        store.add_texts(texts, metadatas=metadatas)
+        return store

sutradb/owl.py

@@ -0,0 +1,304 @@
+"""Client-side OWL validation for SutraDB Python SDK.
+
+The database accepts all triples unconditionally. OWL validation
+happens here in the SDK before sending data to the server. This
+follows the "lean store, smart client" principle.
+
+OWL validation is ENABLED by default. Disable it with:
+    client = SutraClient(owl_validation=False)
+
+The validator loads OWL ontology triples from the database on first use,
+caches them locally, and checks inserts against:
+- rdfs:domain (property domain constraints)
+- rdfs:range (property range constraints)
+- rdfs:subClassOf (type hierarchy)
+- owl:FunctionalProperty (max one value)
+- owl:disjointWith (classes that can't overlap)
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+RDFS_DOMAIN = "http://www.w3.org/2000/01/rdf-schema#domain"
+RDFS_RANGE = "http://www.w3.org/2000/01/rdf-schema#range"
+RDFS_SUBCLASS_OF = "http://www.w3.org/2000/01/rdf-schema#subClassOf"
+OWL_FUNCTIONAL = "http://www.w3.org/2002/07/owl#FunctionalProperty"
+OWL_DISJOINT = "http://www.w3.org/2002/07/owl#disjointWith"
+OWL_EQUIVALENT_CLASS = "http://www.w3.org/2002/07/owl#equivalentClass"
+OWL_SAME_AS = "http://www.w3.org/2002/07/owl#sameAs"
+OWL_INVERSE_OF = "http://www.w3.org/2002/07/owl#inverseOf"
+OWL_SOME_VALUES_FROM = "http://www.w3.org/2002/07/owl#someValuesFrom"
+OWL_ALL_VALUES_FROM = "http://www.w3.org/2002/07/owl#allValuesFrom"
+OWL_ON_PROPERTY = "http://www.w3.org/2002/07/owl#onProperty"
+RDFS_SUB_PROPERTY_OF = "http://www.w3.org/2000/01/rdf-schema#subPropertyOf"
+
+
+class OWLViolation(Exception):
+    """Raised when a triple violates an OWL constraint."""
+
+    def __init__(self, message: str, constraint_type: str, triple: tuple):
+        super().__init__(message)
+        self.constraint_type = constraint_type
+        self.triple = triple
+
+
+class OWLValidator:
+    """Client-side OWL constraint validator.
+
+    Loads ontology axioms from SutraDB and validates triples before insert.
+    """
+
+    def __init__(self):
+        self.domains: dict[str, str] = {}       # property -> domain class
+        self.ranges: dict[str, str] = {}         # property -> range class
+        self.subclass_of: dict[str, set[str]] = {}  # class -> set of parent classes
+        self.sub_property_of: dict[str, set[str]] = {}  # property -> parent properties
+        self.functional: set[str] = set()        # functional properties
+        self.disjoint: dict[str, set[str]] = {}  # class -> disjoint classes
+        self.equivalent_classes: dict[str, set[str]] = {}  # class -> equivalent classes
+        self.same_as: dict[str, set[str]] = {}   # entity -> same-as entities
+        self.inverse_of: dict[str, str] = {}     # property -> inverse property
+        self.restrictions: list[dict] = []      # OWL restrictions (someValues, allValues)
+        self.entity_types: dict[str, set[str]] = {}  # entity -> set of types
+        self._loaded = False
+
+    def load_from_client(self, client) -> None:
+        """Load OWL ontology triples from a SutraDB client."""
+        # Load domain constraints
+        result = client.sparql(
+            f'SELECT ?p ?d WHERE {{ ?p <{RDFS_DOMAIN}> ?d }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            p = row.get("p", {}).get("value", "")
+            d = row.get("d", {}).get("value", "")
+            if p and d:
+                self.domains[p] = d
+
+        # Load range constraints
+        result = client.sparql(
+            f'SELECT ?p ?r WHERE {{ ?p <{RDFS_RANGE}> ?r }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            p = row.get("p", {}).get("value", "")
+            r = row.get("r", {}).get("value", "")
+            if p and r:
+                self.ranges[p] = r
+
+        # Load subclass hierarchy
+        result = client.sparql(
+            f'SELECT ?c ?parent WHERE {{ ?c <{RDFS_SUBCLASS_OF}> ?parent }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            c = row.get("c", {}).get("value", "")
+            parent = row.get("parent", {}).get("value", "")
+            if c and parent:
+                self.subclass_of.setdefault(c, set()).add(parent)
+
+        # Load functional properties
+        result = client.sparql(
+            f'SELECT ?p WHERE {{ ?p <{RDF_TYPE}> <{OWL_FUNCTIONAL}> }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            p = row.get("p", {}).get("value", "")
+            if p:
+                self.functional.add(p)
+
+        # Load property hierarchy
+        result = client.sparql(
+            f'SELECT ?p ?parent WHERE {{ ?p <{RDFS_SUB_PROPERTY_OF}> ?parent }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            p = row.get("p", {}).get("value", "")
+            parent = row.get("parent", {}).get("value", "")
+            if p and parent:
+                self.sub_property_of.setdefault(p, set()).add(parent)
+
+        # Load equivalent classes
+        result = client.sparql(
+            f'SELECT ?a ?b WHERE {{ ?a <{OWL_EQUIVALENT_CLASS}> ?b }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            a = row.get("a", {}).get("value", "")
+            b = row.get("b", {}).get("value", "")
+            if a and b:
+                self.equivalent_classes.setdefault(a, set()).add(b)
+                self.equivalent_classes.setdefault(b, set()).add(a)
+
+        # Load owl:sameAs
+        result = client.sparql(
+            f'SELECT ?a ?b WHERE {{ ?a <{OWL_SAME_AS}> ?b }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            a = row.get("a", {}).get("value", "")
+            b = row.get("b", {}).get("value", "")
+            if a and b:
+                self.same_as.setdefault(a, set()).add(b)
+                self.same_as.setdefault(b, set()).add(a)
+
+        # Load owl:inverseOf
+        result = client.sparql(
+            f'SELECT ?p ?inv WHERE {{ ?p <{OWL_INVERSE_OF}> ?inv }}'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            p = row.get("p", {}).get("value", "")
+            inv = row.get("inv", {}).get("value", "")
+            if p and inv:
+                self.inverse_of[p] = inv
+                self.inverse_of[inv] = p
+
+        # Load entity types (for validation)
+        result = client.sparql(
+            f'SELECT ?e ?t WHERE {{ ?e <{RDF_TYPE}> ?t }} LIMIT 10000'
+        )
+        for row in result.get("results", {}).get("bindings", []):
+            e = row.get("e", {}).get("value", "")
+            t = row.get("t", {}).get("value", "")
+            if e and t:
+                self.entity_types.setdefault(e, set()).add(t)
+
+        self._loaded = True
+
+    def is_loaded(self) -> bool:
+        """Whether the ontology has been loaded."""
+        return self._loaded
+
+    def has_constraints(self) -> bool:
+        """Whether any OWL constraints exist in the database."""
+        return bool(
+            self.domains or self.ranges or self.functional or self.disjoint
+        )
+
+    def get_all_types(self, class_iri: str) -> set[str]:
+        """Get a class and all its ancestors via rdfs:subClassOf."""
+        result = {class_iri}
+        queue = [class_iri]
+        while queue:
+            current = queue.pop()
+            for parent in self.subclass_of.get(current, set()):
+                if parent not in result:
+                    result.add(parent)
+                    queue.append(parent)
+        return result
+
+    def validate_triple(
+        self, subject: str, predicate: str, obj: str
+    ) -> Optional[OWLViolation]:
+        """Validate a single triple against OWL constraints.
+
+        Returns None if valid, or an OWLViolation if invalid.
+        """
+        triple = (subject, predicate, obj)
+
+        # Domain check
+        if predicate in self.domains:
+            expected_domain = self.domains[predicate]
+            subject_types = self.entity_types.get(subject, set())
+            if subject_types:
+                all_types = set()
+                for t in subject_types:
+                    all_types |= self.get_all_types(t)
+                if expected_domain not in all_types:
+                    return OWLViolation(
+                        f"Domain violation: {predicate} requires subject of type "
+                        f"{expected_domain}, but {subject} has types {subject_types}",
+                        "domain",
+                        triple,
+                    )
+
+        # Range check
+        if predicate in self.ranges and not obj.startswith('"'):
+            expected_range = self.ranges[predicate]
+            object_types = self.entity_types.get(obj, set())
+            if object_types:
+                all_types = set()
+                for t in object_types:
+                    all_types |= self.get_all_types(t)
+                if expected_range not in all_types:
+                    return OWLViolation(
+                        f"Range violation: {predicate} requires object of type "
+                        f"{expected_range}, but {obj} has types {object_types}",
+                        "range",
+                        triple,
+                    )
+
+        # Disjoint class check (when assigning a type)
+        if predicate == RDF_TYPE:
+            existing_types = self.entity_types.get(subject, set())
+            for existing_type in existing_types:
+                disjoint = self.disjoint.get(existing_type, set())
+                if obj in disjoint:
+                    return OWLViolation(
+                        f"Disjoint violation: {subject} is already type "
+                        f"{existing_type}, which is disjoint with {obj}",
+                        "disjoint",
+                        triple,
+                    )
+
+        return None  # Valid
+
+    def generate_verification_queries(self) -> list[tuple[str, str]]:
+        """Generate SPARQL queries that check for OWL constraint violations.
+
+        Returns a list of (description, sparql_query) tuples.
+        Each query returns rows that represent violations.
+        """
+        queries = []
+
+        # Domain violations
+        for prop, domain_class in self.domains.items():
+            queries.append((
+                f"Domain violation: {prop} requires subject of type {domain_class}",
+                f"SELECT ?s WHERE {{ ?s <{prop}> ?o . "
+                f"FILTER NOT EXISTS {{ ?s <{RDF_TYPE}> <{domain_class}> }} }}"
+            ))
+
+        # Range violations
+        for prop, range_class in self.ranges.items():
+            queries.append((
+                f"Range violation: {prop} requires object of type {range_class}",
+                f"SELECT ?o WHERE {{ ?s <{prop}> ?o . "
+                f"FILTER NOT EXISTS {{ ?o <{RDF_TYPE}> <{range_class}> }} }}"
+            ))
+
+        # Functional property violations (more than one value)
+        for prop in self.functional:
+            queries.append((
+                f"Functional violation: {prop} should have at most one value per subject",
+                f"SELECT ?s WHERE {{ ?s <{prop}> ?o1 . ?s <{prop}> ?o2 . "
+                f"FILTER(?o1 != ?o2) }}"
+            ))
+
+        # Disjoint class violations
+        for cls, disjoint_set in self.disjoint.items():
+            for other in disjoint_set:
+                queries.append((
+                    f"Disjoint violation: {cls} and {other} cannot overlap",
+                    f"SELECT ?x WHERE {{ ?x <{RDF_TYPE}> <{cls}> . "
+                    f"?x <{RDF_TYPE}> <{other}> }}"
+                ))
+
+        return queries
+
+    def validate_ntriples(self, ntriples: str) -> list[OWLViolation]:
+        """Validate a block of N-Triples. Returns list of violations."""
+        violations = []
+        for line in ntriples.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            # Simple N-Triples parsing (subject predicate object .)
+            parts = line.split(None, 2)
+            if len(parts) < 3:
+                continue
+            s = parts[0].strip("<>")
+            p = parts[1].strip("<>")
+            o_raw = parts[2].rstrip(" .")
+            o = o_raw.strip("<>") if o_raw.startswith("<") else o_raw
+
+            violation = self.validate_triple(s, p, o)
+            if violation:
+                violations.append(violation)
+
+        return violations

sutradb-0.3.2.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: sutradb
+Version: 0.3.2
+Project-URL: Homepage, https://sutradb.org/
+Project-URL: Repository, https://github.com/EmmaLeonhart/SutraDB
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'

sutradb-0.3.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+sutradb/__init__.py,sha256=L5l3MVIjH2JVgYMQU70_YrrAJyIIEp-sAyS3XsHapSg,157
+sutradb/_version.py,sha256=vNiWJ14r_cw5t_7UDqDQIVZvladKFGyHH2avsLpN7Vg,22
+sutradb/client.py,sha256=wziV1VyT9zRJs9NbE9u0Gu-DzGYiYWRx6jAzvjGgass,9420
+sutradb/jupyter.py,sha256=3mkpibI3pONYJmLHmn4VLpMFFPcvvCGGkLxrRjyufYU,3746
+sutradb/langchain.py,sha256=qlKnXkk1U54KrSO84s48LxgzuEl7SWInDiRdOGNQgdQ,4770
+sutradb/owl.py,sha256=alOZu6f57EGGVVTaO2q7r2H2kOsqYu1XJ9n5Q_s8tK4,12382
+sutradb-0.3.2.dist-info/METADATA,sha256=V1b3Z_KXtELm6ksDTnwYm01MWQFMBq2xQhTk-V-lLps,223
+sutradb-0.3.2.dist-info/WHEEL,sha256=e22IIVjxDyt0lABi4WpktFIGsmO_ebSDXLnPUbPK0E0,105
+sutradb-0.3.2.dist-info/RECORD,,

sutradb-0.3.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any