rdf4j-python 0.1.2__tar.gz → 0.1.4__tar.gz

{rdf4j_python-0.1.2/rdf4j_python.egg-info → rdf4j_python-0.1.4}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: rdf4j-python
-Version: 0.1.2
+Version: 0.1.4
 Summary: The Python client for RDF4J
 Author-email: Chengxu Bian <cbian564@gmail.com>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: rdflib>=7.1.4
+Requires-Dist: pyoxigraph>=0.4.10
+Provides-Extra: sparqlwrapper
+Requires-Dist: sparqlwrapper>=2.0.0; extra == "sparqlwrapper"
 Dynamic: license-file
 
 # 🐍 rdf4j-python
@@ -60,6 +62,7 @@ async with AsyncRdf4j("http://localhost:19780/rdf4j-server") as db:
         Literal("test_object"),
     )
     await repo.get_statements(subject=IRI("http://example.com/subject"))
+    results = await repo.query("SELECT * WHERE { ?s ?p ?o }")
 ```
 
 For more detailed examples, refer to the [examples](https://github.com/odysa/rdf4j-python/tree/main/examples) directory.

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/README.md

@@ -48,6 +48,7 @@ async with AsyncRdf4j("http://localhost:19780/rdf4j-server") as db:
         Literal("test_object"),
     )
     await repo.get_statements(subject=IRI("http://example.com/subject"))
+    results = await repo.query("SELECT * WHERE { ?s ?p ?o }")
 ```
 
 For more detailed examples, refer to the [examples](https://github.com/odysa/rdf4j-python/tree/main/examples) directory.

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/pyproject.toml

@@ -1,11 +1,14 @@
 [project]
 name = "rdf4j-python"
 authors = [{ name = "Chengxu Bian", email = "cbian564@gmail.com" }]
-version = "0.1.2"
+version = "0.1.4"
 description = "The Python client for RDF4J"
 readme = "README.md"
 requires-python = ">=3.10"
-dependencies = ["httpx>=0.28.1", "rdflib>=7.1.4"]
+dependencies = ["httpx>=0.28.1", "pyoxigraph>=0.4.10"]
+
+[project.optional-dependencies]
+sparqlwrapper = ["sparqlwrapper>=2.0.0"]
 
 [dependency-groups]
 dev = [
@@ -13,11 +16,9 @@ dev = [
     "pytest-asyncio>=0.26.0",
     "pytest-docker>=3.2.1",
     "ruff>=0.11.8",
+    "ty>=0.0.1a7",
 ]
-docs = [
-    "furo>=2024.8.6",
-    "sphinx>=8",
-]
+docs = ["furo>=2024.8.6", "sphinx>=8"]
 
 
 [tool.pytest.ini_options]

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/rdf4j_python/_driver/_async_named_graph.py

@@ -1,8 +1,9 @@
 from typing import Iterable
 
+import pyoxigraph as og
+
 from rdf4j_python._client import AsyncApiClient
-from rdf4j_python.model import RDF4JDataSet
-from rdf4j_python.model.term import IRI, RDFStatement
+from rdf4j_python.model.term import IRI, Quad, QuadResultSet, Triple
 from rdf4j_python.utils.const import Rdf4jContentType
 from rdf4j_python.utils.helpers import serialize_statements
 
@@ -22,11 +23,11 @@ class AsyncNamedGraph:
         self._repository_id = repository_id
         self._graph_uri = graph_uri
 
-    async def get(self) -> RDF4JDataSet:
+    async def get(self) -> QuadResultSet:
         """Fetches all RDF statements from this named graph.
 
         Returns:
-            str: RDF data serialized in the requested format.
+            QuadResultSet: RDF data serialized in the requested format.
 
         Raises:
             httpx.HTTPStatusError: If the request fails.
@@ -35,13 +36,13 @@ class AsyncNamedGraph:
         headers = {"Accept": Rdf4jContentType.NQUADS}
         response = await self._client.get(path, headers=headers)
         response.raise_for_status()
-        return RDF4JDataSet.from_raw_text(response.text)
+        return og.parse(response.content, format=og.RdfFormat.N_QUADS)
 
-    async def add(self, statements: Iterable[RDFStatement]):
+    async def add(self, statements: Iterable[Quad] | Iterable[Triple]):
         """Adds RDF statements to this named graph.
 
         Args:
-            statements (Iterable[RDFStatement]): RDF statements to add.
+            statements (Iterable[Quad] | Iterable[Triple]): RDF statements to add.
 
         Raises:
             httpx.HTTPStatusError: If the request fails.

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/rdf4j_python/_driver/_async_rdf4j_db.py

@@ -1,5 +1,5 @@
 import httpx
-import rdflib
+import pyoxigraph as og
 
 from rdf4j_python._client import AsyncApiClient
 from rdf4j_python.exception.repo_exception import (
@@ -66,12 +66,13 @@ class AsyncRdf4j:
             "/repositories",
             headers={"Accept": Rdf4jContentType.SPARQL_RESULTS_JSON},
         )
-        result = rdflib.query.Result.parse(
-            response, format=Rdf4jContentType.SPARQL_RESULTS_JSON
+        query_solutions = og.parse_query_results(
+            response.text, format=og.QueryResultsFormat.JSON
         )
+        assert isinstance(query_solutions, og.QuerySolutions)
         return [
-            RepositoryMetadata.from_rdflib_binding(binding)
-            for binding in result.bindings
+            RepositoryMetadata.from_sparql_query_solution(query_solution)
+            for query_solution in query_solutions
         ]
 
     async def get_repository(self, repository_id: str) -> AsyncRdf4JRepository:

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/rdf4j_python/_driver/_async_repository.py

@@ -1,10 +1,7 @@
 from typing import Iterable, Optional
 
 import httpx
-import rdflib
-import rdflib.resource
-import rdflib.serializer
-import rdflib.store
+import pyoxigraph as og
 
 from rdf4j_python._client import AsyncApiClient
 from rdf4j_python._driver._async_named_graph import AsyncNamedGraph
@@ -14,21 +11,35 @@ from rdf4j_python.exception.repo_exception import (
     RepositoryNotFoundException,
     RepositoryUpdateException,
 )
-from rdf4j_python.model import Namespace, RDF4JDataSet
+from rdf4j_python.model import Namespace
 from rdf4j_python.model.term import (
+    IRI,
     Context,
     Object,
     Predicate,
-    RDFStatement,
+    Quad,
+    QuadResultSet,
     Subject,
+    Triple,
 )
 from rdf4j_python.utils.const import Rdf4jContentType
 from rdf4j_python.utils.helpers import serialize_statements
 
+try:
+    from SPARQLWrapper import SPARQLWrapper
+
+    _has_sparql_wrapper = True
+except ImportError:
+    _has_sparql_wrapper = False
+
 
 class AsyncRdf4JRepository:
     """Asynchronous interface for interacting with an RDF4J repository."""
 
+    _client: AsyncApiClient
+    _repository_id: str
+    _sparql_wrapper: Optional["SPARQLWrapper"] = None
+
     def __init__(self, client: AsyncApiClient, repository_id: str):
         """Initializes the repository interface.
 
@@ -39,32 +50,47 @@ class AsyncRdf4JRepository:
         self._client = client
         self._repository_id = repository_id
 
+    async def get_sparql_wrapper(self) -> "SPARQLWrapper":
+        """Returns the SPARQLWrapper for the repository.
+
+        Returns:
+            SPARQLWrapper: The SPARQLWrapper for the repository.
+        """
+        if not _has_sparql_wrapper:
+            raise ImportError(
+                "SPARQLWrapper is not installed. Please install it with `pip install rdf4j-python[sparqlwrapper]`"
+            )
+
+        if self._sparql_wrapper is None:
+            self._sparql_wrapper = SPARQLWrapper(
+                f"{self._client.get_base_url()}/repositories/{self._repository_id}"
+            )
+        return self._sparql_wrapper
+
     async def query(
         self,
         sparql_query: str,
         infer: bool = True,
-        accept: Rdf4jContentType = Rdf4jContentType.SPARQL_RESULTS_JSON,
-    ):
+    ) -> og.QuerySolutions | og.QueryBoolean:
         """Executes a SPARQL SELECT query.
 
         Args:
             sparql_query (str): The SPARQL query string.
             infer (bool): Whether to include inferred statements. Defaults to True.
-            accept (Rdf4jContentType): The expected response format.
 
         Returns:
-            dict or str: Parsed JSON results or raw response text.
+            og.QuerySolutions | og.QueryBoolean: Parsed query results.
         """
         path = f"/repositories/{self._repository_id}"
         params = {"query": sparql_query, "infer": str(infer).lower()}
-        headers = {"Accept": accept.value}
+        headers = {"Accept": Rdf4jContentType.SPARQL_RESULTS_JSON}
         response = await self._client.get(path, params=params, headers=headers)
         self._handle_repo_not_found_exception(response)
-        if "json" in response.headers.get("Content-Type", ""):
-            return response.json()
-        return response.text
+        return og.parse_query_results(response.text, format=og.QueryResultsFormat.JSON)
 
-    async def update(self, sparql_update: str):
+    async def update(
+        self, sparql_update_query: str, content_type: Rdf4jContentType
+    ) -> None:
         """Executes a SPARQL UPDATE command.
 
         Args:
@@ -74,11 +100,15 @@ class AsyncRdf4JRepository:
             RepositoryNotFoundException: If the repository doesn't exist.
             httpx.HTTPStatusError: If the update fails.
         """
+        # TODO: handle update results
         path = f"/repositories/{self._repository_id}/statements"
-        headers = {"Content-Type": Rdf4jContentType.SPARQL_UPDATE.value}
-        response = await self._client.post(path, data=sparql_update, headers=headers)
+        headers = {"Content-Type": content_type}
+        response = await self._client.post(
+            path, content=sparql_update_query, headers=headers
+        )
         self._handle_repo_not_found_exception(response)
-        response.raise_for_status()
+        if response.status_code != httpx.codes.NO_CONTENT:
+            raise RepositoryUpdateException(f"Failed to update: {response.text}")
 
     async def get_namespaces(self):
         """Retrieves all namespaces in the repository.
@@ -92,26 +122,33 @@ class AsyncRdf4JRepository:
         path = f"/repositories/{self._repository_id}/namespaces"
         headers = {"Accept": Rdf4jContentType.SPARQL_RESULTS_JSON}
         response = await self._client.get(path, headers=headers)
-        result = rdflib.query.Result.parse(
-            response, format=Rdf4jContentType.SPARQL_RESULTS_JSON
-        )
         self._handle_repo_not_found_exception(response)
-        return [Namespace.from_rdflib_binding(binding) for binding in result.bindings]
 
-    async def set_namespace(self, prefix: str, namespace: str):
+        query_solutions = og.parse_query_results(
+            response.text, format=og.QueryResultsFormat.JSON
+        )
+        assert isinstance(query_solutions, og.QuerySolutions)
+        return [
+            Namespace.from_sparql_query_solution(query_solution)
+            for query_solution in query_solutions
+        ]
+
+    async def set_namespace(self, prefix: str, namespace: IRI):
         """Sets a namespace prefix.
 
         Args:
             prefix (str): The namespace prefix.
-            namespace (str): The namespace URI.
+            namespace (IRI): The namespace URI.
 
         Raises:
             RepositoryNotFoundException: If the repository doesn't exist.
             NamespaceException: If the request fails.
         """
         path = f"/repositories/{self._repository_id}/namespaces/{prefix}"
-        headers = {"Content-Type": Rdf4jContentType.NTRIPLES.value}
-        response = await self._client.put(path, content=namespace, headers=headers)
+        headers = {"Content-Type": Rdf4jContentType.NTRIPLES}
+        response = await self._client.put(
+            path, content=namespace.value, headers=headers
+        )
         self._handle_repo_not_found_exception(response)
         if response.status_code != httpx.codes.NO_CONTENT:
             raise NamespaceException(f"Failed to set namespace: {response.text}")
@@ -130,7 +167,7 @@ class AsyncRdf4JRepository:
             NamespaceException: If retrieval fails.
         """
         path = f"/repositories/{self._repository_id}/namespaces/{prefix}"
-        headers = {"Accept": Rdf4jContentType.NTRIPLES.value}
+        headers = {"Accept": Rdf4jContentType.NTRIPLES}
         response = await self._client.get(path, headers=headers)
         self._handle_repo_not_found_exception(response)
 
@@ -192,7 +229,7 @@ class AsyncRdf4JRepository:
         object_: Optional[Object] = None,
         contexts: Optional[list[Context]] = None,
         infer: bool = True,
-    ) -> RDF4JDataSet:
+    ) -> QuadResultSet:
         """Retrieves statements matching the given pattern.
 
         Args:
@@ -202,7 +239,7 @@ class AsyncRdf4JRepository:
             contexts (Optional[list[Context]]): Filter by context (named graph).
 
         Returns:
-            DataSet: Dataset of matching RDF statements.
+            QuadResultSet: QuadResultSet of matching RDF statements.
 
         Raises:
             RepositoryNotFoundException: If the repository doesn't exist.
@@ -211,20 +248,18 @@ class AsyncRdf4JRepository:
         params = {}
 
         if subject:
-            params["subj"] = subject.n3()
+            params["subj"] = str(subject)
         if predicate:
-            params["pred"] = predicate.n3()
+            params["pred"] = str(predicate)
         if object_:
-            params["obj"] = object_.n3()
+            params["obj"] = str(object_)
         if contexts:
-            params["context"] = [ctx.n3() for ctx in contexts]
+            params["context"] = [str(ctx) for ctx in contexts]
         params["infer"] = str(infer).lower()
 
         headers = {"Accept": Rdf4jContentType.NQUADS}
         response = await self._client.get(path, params=params, headers=headers)
-        dataset = RDF4JDataSet()
-        dataset.parse(data=response.text, format="nquads")
-        return dataset
+        return og.parse(response.content, format=og.RdfFormat.N_QUADS)
 
     async def delete_statements(
         self,
@@ -250,13 +285,13 @@ class AsyncRdf4JRepository:
         params = {}
 
         if subject:
-            params["subj"] = subject.n3()
+            params["subj"] = str(subject)
         if predicate:
-            params["pred"] = predicate.n3()
+            params["pred"] = str(predicate)
         if object_:
-            params["obj"] = object_.n3()
+            params["obj"] = str(object_)
         if contexts:
-            params["context"] = [ctx.n3() for ctx in contexts]
+            params["context"] = [str(ctx) for ctx in contexts]
 
         response = await self._client.delete(path, params=params)
         self._handle_repo_not_found_exception(response)
@@ -286,21 +321,26 @@ class AsyncRdf4JRepository:
             httpx.HTTPStatusError: If addition fails.
         """
         path = f"/repositories/{self._repository_id}/statements"
+        statement: Triple | Quad
+        if context is None:
+            statement = Triple(subject, predicate, object)
+        else:
+            statement = Quad(subject, predicate, object, context)
+
         response = await self._client.post(
             path,
-            content=serialize_statements([(subject, predicate, object, context)]),
+            content=serialize_statements([statement]),
             headers={"Content-Type": Rdf4jContentType.NQUADS},
         )
         self._handle_repo_not_found_exception(response)
         if response.status_code != httpx.codes.NO_CONTENT:
             raise RepositoryUpdateException(f"Failed to add statement: {response.text}")
 
-    async def add_statements(self, statements: Iterable[RDFStatement]):
+    async def add_statements(self, statements: Iterable[Quad] | Iterable[Triple]):
         """Adds a list of RDF statements to the repository.
 
         Args:
-            statements (Iterable[RDFStatement]): A list of RDF statements.
-            RDFStatement: A tuple of subject, predicate, object, and context.
+            statements (Iterable[Quad] | Iterable[Triple]): A list of RDF statements.
 
         Raises:
             RepositoryNotFoundException: If the repository doesn't exist.
@@ -320,26 +360,26 @@ class AsyncRdf4JRepository:
 
     async def replace_statements(
         self,
-        statements: Iterable[RDFStatement],
-        contexts: Optional[list[Context]] = None,
+        statements: Iterable[Quad] | Iterable[Triple],
+        contexts: Optional[Iterable[Context]] = None,
         base_uri: Optional[str] = None,
     ):
         """Replaces all repository statements with the given RDF data.
 
         Args:
-            statements (Iterable[RDFStatement]): RDF statements to load.
-            contexts (Optional[list[Context]]): One or more specific contexts to restrict deletion to.
+            statements (Iterable[Quad] | Iterable[Triple]): RDF statements to load.
+            contexts (Optional[Iterable[Context]]): One or more specific contexts to restrict deletion to.
 
         Raises:
             RepositoryNotFoundException: If the repository doesn't exist.
             httpx.HTTPStatusError: If the operation fails.
         """
         path = f"/repositories/{self._repository_id}/statements"
-        headers = {"Content-Type": Rdf4jContentType.NQUADS.value}
+        headers = {"Content-Type": Rdf4jContentType.NQUADS}
 
         params = {}
         if contexts:
-            params["context"] = [ctx.n3() for ctx in contexts]
+            params["context"] = [str(ctx) for ctx in contexts]
         if base_uri:
             params["baseUri"] = base_uri
 

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/rdf4j_python/model/__init__.py

@@ -2,12 +2,10 @@
 RDF4J Python Model Module
 """
 
-from ._dataset import RDF4JDataSet
 from ._namespace import Namespace
 from ._repository_info import RepositoryMetadata
 
 __all__ = [
     "Namespace",
     "RepositoryMetadata",
-    "RDF4JDataSet",
 ]

{rdf4j_python-0.1.2 → rdf4j_python-0.1.4}/rdf4j_python/model/_namespace.py

@@ -1,11 +1,32 @@
-from typing import Mapping
-
-from rdflib.namespace import Namespace as RdflibNamespace
-from rdflib.term import Identifier, Variable
+import pyoxigraph as og
 
 from rdf4j_python.model.term import IRI
 
-from ._base_model import _BaseModel
+
+class _Namespace(str):
+    def __new__(cls, value: str | bytes) -> "Namespace":
+        try:
+            rt = str.__new__(cls, value)
+        except UnicodeDecodeError:
+            rt = str.__new__(cls, value, "utf-8")
+        return rt
+
+    def term(self, name: str) -> IRI:
+        return IRI(self + (name if isinstance(name, str) else ""))
+
+    def __getitem__(self, key: str) -> IRI:
+        return self.term(key)
+
+    def __getattr__(self, name: str) -> IRI:
+        if name.startswith("__"):
+            raise AttributeError
+        return self.term(name)
+
+    def __repr__(self) -> str:
+        return f"Namespace({super().__repr__()})"
+
+    def __contains__(self, ref: str) -> bool:
+        return ref.startswith(self)
 
 
 class Namespace:
@@ -14,7 +35,7 @@ class Namespace:
     """
 
     _prefix: str
-    _namespace: RdflibNamespace
+    _namespace: _Namespace
 
     def __init__(self, prefix: str, namespace: str):
         """
@@ -25,24 +46,26 @@ class Namespace:
             namespace (str): The namespace URI.
         """
         self._prefix = prefix
-        self._namespace = RdflibNamespace(namespace)
+        self._namespace = _Namespace(namespace)
 
     @classmethod
-    def from_rdflib_binding(cls, binding: Mapping[Variable, Identifier]) -> "Namespace":
+    def from_sparql_query_solution(
+        cls, query_solution: og.QuerySolution
+    ) -> "Namespace":
         """
-        Creates a Namespace from a RDFlib binding.
+        Creates a Namespace from a  binding.
 
         Args:
-            binding (Mapping[Variable, Identifier]): The RDFlib binding.
+            binding (Mapping[Variable, Identifier]): The  binding.
 
         Returns:
             Namespace: The created Namespace.
         """
-        prefix = _BaseModel.get_literal(binding, "prefix", "")
-        namespace = _BaseModel.get_literal(binding, "namespace", "")
+        prefix: og.Literal = query_solution[og.Variable("prefix")]
+        namespace: og.NamedNode = query_solution[og.Variable("namespace")]
         return cls(
-            prefix=prefix,
-            namespace=namespace,
+            prefix=prefix.value,
+            namespace=namespace.value,
         )
 
     def __str__(self):
@@ -85,7 +108,7 @@ class Namespace:
         Returns:
             IRI: The IRI for the term.
         """
-        return IRI(self._namespace.term(name))
+        return self._namespace.term(name)
 
     def __getitem__(self, item: str) -> IRI:
         """

rdf4j_python-0.1.4/rdf4j_python/model/_repository_info.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+
+import pyoxigraph as og
+
+
+@dataclass
+class RepositoryMetadata:
+    """
+    Represents a repository metadata RDF4J.
+    """
+
+    id: str  # The repository identifier
+    uri: str  # The full URI to the repository
+    title: str  # A human-readable title (currently reusing id)
+    readable: bool  # Whether the repository is readable
+    writable: bool  # Whether the repository is writable
+
+    def __str__(self):
+        """
+        Returns a string representation of the RepositoryMetadata.
+
+        Returns:
+            str: A string representation of the RepositoryMetadata.
+        """
+        return f"Repository(id={self.id}, title={self.title}, uri={self.uri})"
+
+    @classmethod
+    def from_sparql_query_solution(
+        cls, query_solution: og.QuerySolution
+    ) -> "RepositoryMetadata":
+        """
+        Create a RepositoryMetadata instance from a SPARQL query result.
+
+        Args:
+            query_solution (og.QuerySolution): The SPARQL query result.
+
+        Returns:
+            RepositoryMetadata: The RepositoryMetadata instance.
+
+        Raises:
+            ValueError: If the query solution is missing required fields.
+        """
+
+        # Construct and return the Repository object
+        if query_solution["id"] is None:
+            raise ValueError("id is required")
+        if query_solution["uri"] is None:
+            raise ValueError("uri is required")
+        if query_solution["title"] is None:
+            raise ValueError("title is required")
+        if query_solution["readable"] is None:
+            raise ValueError("readable is required")
+        if query_solution["writable"] is None:
+            raise ValueError("writable is required")
+
+        return cls(
+            id=query_solution["id"].value,
+            uri=query_solution["uri"].value,
+            title=query_solution["title"].value,
+            readable=bool(query_solution["readable"].value),
+            writable=bool(query_solution["writable"].value),
+        )