rdf4j-python 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

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/_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/_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/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/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/model/_repository_info.py

@@ -1,13 +1,10 @@
 from dataclasses import dataclass
-from typing import Mapping
 
-from rdflib.term import Identifier, Variable
-
-from ._base_model import _BaseModel
+import pyoxigraph as og
 
 
 @dataclass
-class RepositoryMetadata(_BaseModel):
+class RepositoryMetadata:
     """
     Represents a repository metadata RDF4J.
     """
@@ -28,25 +25,38 @@ class RepositoryMetadata(_BaseModel):
         return f"Repository(id={self.id}, title={self.title}, uri={self.uri})"
 
     @classmethod
-    def from_rdflib_binding(
-        cls, result: Mapping[Variable, Identifier]
+    def from_sparql_query_solution(
+        cls, query_solution: og.QuerySolution
     ) -> "RepositoryMetadata":
         """
-        Create a Repository instance from a SPARQL query result
-        represented as a Mapping from rdflib Variables to Identifiers.
+        Create a RepositoryMetadata instance from a SPARQL query result.
 
         Args:
-            result (Mapping[Variable, Identifier]): The SPARQL query result.
+            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=_BaseModel.get_literal(result, "id", ""),
-            uri=_BaseModel.get_uri(result, "uri", ""),
-            title=_BaseModel.get_literal(result, "title", ""),
-            readable=_BaseModel.get_literal(result, "readable", False),
-            writable=_BaseModel.get_literal(result, "writable", False),
+            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),
         )

rdf4j_python/model/repository_config.py

@@ -1,10 +1,15 @@
 from typing import Any, Dict, Optional
 
-from rdflib import BNode, Graph, Literal, Namespace, URIRef
-from rdflib.namespace import RDF, RDFS, XSD
+from pyoxigraph import Dataset, Quad, RdfFormat, serialize
+
+from rdf4j_python.model import Namespace
+from rdf4j_python.model.term import IRI as URIRef
+from rdf4j_python.model.term import BlankNode as BNode
+from rdf4j_python.model.term import Literal
+from rdf4j_python.model.vocabulary import RDF, RDFS, XSD
 
 # Define the RDF4J configuration namespace
-CONFIG = Namespace("tag:rdf4j.org,2023:config/")
+CONFIG = Namespace("config", "tag:rdf4j.org,2023:config/")
 
 
 class RepositoryConfig:
@@ -54,35 +59,32 @@ class RepositoryConfig:
         """
         return self._title
 
-    def to_turtle(self) -> str:
+    def to_turtle(self) -> bytes | None:
         """
-        Serializes the Repository configuration to Turtle syntax using RDFlib.
+        Serializes the Repository configuration to Turtle syntax using .
 
         Returns:
-            str: A UTF-8 encoded Turtle string representing the RDF4J repository configuration.
+            bytes | None: A UTF-8 encoded Turtle string representing the RDF4J repository configuration.
                 The serialization includes the repository ID, optional human-readable title,
                 and nested repository implementation configuration if available.
 
         Raises:
             ValueError: If any of the configuration values are of unsupported types during serialization.
         """
-        graph = Graph()
-        graph.bind("rdfs", RDFS)
-        graph.bind("config", CONFIG)
-        graph.bind("xsd", XSD)
+        graph = Dataset()
         repo_node = BNode()
-        graph.add((repo_node, RDF["type"], CONFIG["Repository"]))
+        graph.add(Quad(repo_node, RDF["type"], CONFIG["Repository"], None))
 
-        graph.add((repo_node, CONFIG["rep.id"], Literal(self._repo_id)))
+        graph.add(Quad(repo_node, CONFIG["rep.id"], Literal(self._repo_id), None))
 
         if self._title:
-            graph.add((repo_node, RDFS["label"], Literal(self._title)))
+            graph.add(Quad(repo_node, RDFS["label"], Literal(self._title), None))
 
         if self._impl:
             impl_node = self._impl.add_to_graph(graph)
-            graph.add((repo_node, CONFIG["rep.impl"], impl_node))
+            graph.add(Quad(repo_node, CONFIG["rep.impl"], impl_node, None))
 
-        return graph.serialize(format="turtle").encode("utf-8")
+        return serialize(graph, format=RdfFormat.TURTLE)
 
     class Builder:
         """
@@ -168,14 +170,14 @@ class RepositoryConfig:
 
 class RepositoryImplConfig:
     """
-    Base class for repository implementation configurations using RDFlib.
+    Base class for repository implementation configurations using .
     """
 
     def __init__(self, rep_type: str):
         self.rep_type = rep_type
         self.config_params: Dict[str, Any] = {}
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the repository implementation configuration to the RDF graph.
 
@@ -183,28 +185,45 @@ class RepositoryImplConfig:
             The RDF node representing this configuration.
         """
         sail_node = BNode()
-        graph.add((sail_node, CONFIG["rep.type"], Literal(self.rep_type)))
+        graph.add(Quad(sail_node, CONFIG["rep.type"], Literal(self.rep_type), None))
         for key, value in self.config_params.items():
             if isinstance(value, str):
-                graph.add((sail_node, CONFIG[key], Literal(value)))
-            elif isinstance(value, int):
+                graph.add(Quad(sail_node, CONFIG[key], Literal(value), None))
+            elif isinstance(value, int) and not isinstance(value, bool):
                 graph.add(
-                    (sail_node, CONFIG[key], Literal(value, datatype=XSD.integer))
+                    Quad(
+                        sail_node,
+                        CONFIG[key],
+                        Literal(value, datatype=XSD["integer"]),
+                        None,
+                    )
                 )
             elif isinstance(value, float):
-                graph.add((sail_node, CONFIG[key], Literal(value, datatype=XSD.double)))
+                graph.add(
+                    Quad(
+                        sail_node,
+                        CONFIG[key],
+                        Literal(value, datatype=XSD["double"]),
+                        None,
+                    )
+                )
             elif isinstance(value, bool):
                 graph.add(
-                    (sail_node, CONFIG[key], Literal(value, datatype=XSD.boolean))
+                    Quad(
+                        sail_node,
+                        CONFIG[key],
+                        Literal(str(value).lower(), datatype=XSD["boolean"]),
+                        None,
+                    )
                 )
             elif isinstance(value, list):
                 for item in value:
-                    graph.add((sail_node, CONFIG[key], URIRef(item)))  # Assuming IRIs
+                    graph.add(Quad(sail_node, CONFIG[key], URIRef(item), None))
             elif isinstance(value, RepositoryImplConfig) or isinstance(
                 value, SailConfig
             ):
                 nested_node = value.add_to_graph(graph)
-                graph.add((sail_node, CONFIG[key], nested_node))
+                graph.add(Quad(sail_node, CONFIG[key], nested_node, None))
             else:
                 raise ValueError(f"Unsupported configuration value type: {type(value)}")
         return sail_node
@@ -212,7 +231,7 @@ class RepositoryImplConfig:
 
 class SPARQLRepositoryConfig(RepositoryImplConfig):
     """
-    Configuration for a SPARQLRepository using RDFlib.
+    Configuration for a SPARQLRepository.
     """
 
     TYPE = "openrdf:SPARQLRepository"
@@ -265,7 +284,7 @@ class SPARQLRepositoryConfig(RepositoryImplConfig):
 
 class HTTPRepositoryConfig(RepositoryImplConfig):
     """
-    Configuration for an HTTPRepository using RDFlib.
+    Configuration for an HTTPRepository.
     """
 
     TYPE = "openrdf:HTTPRepository"
@@ -320,7 +339,7 @@ class HTTPRepositoryConfig(RepositoryImplConfig):
 
 class SailRepositoryConfig(RepositoryImplConfig):
     """
-    Configuration for a SailRepository using RDFlib.
+    Configuration for a SailRepository.
     """
 
     TYPE = "openrdf:SailRepository"
@@ -329,7 +348,7 @@ class SailRepositoryConfig(RepositoryImplConfig):
         super().__init__(rep_type=SailRepositoryConfig.TYPE)
         self.config_params["sail.impl"] = sail_impl
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the SailRepository configuration to the RDF graph.
         """
@@ -364,7 +383,7 @@ class SailRepositoryConfig(RepositoryImplConfig):
 
 class DatasetRepositoryConfig(RepositoryImplConfig):
     """
-    Configuration for a DatasetRepository using RDFlib.
+    Configuration for a DatasetRepository using .
     """
 
     TYPE = "openrdf:DatasetRepository"
@@ -373,7 +392,7 @@ class DatasetRepositoryConfig(RepositoryImplConfig):
         super().__init__(rep_type=DatasetRepositoryConfig.TYPE)
         self.config_params["delegate"] = delegate
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the DatasetRepository configuration to the RDF Graph
         """
@@ -390,7 +409,7 @@ class DatasetRepositoryConfig(RepositoryImplConfig):
 
 class SailConfig:
     """
-    Base class for SAIL configurations using RDFlib.
+    Base class for SAIL configurations using .
     """
 
     def __init__(
@@ -410,7 +429,7 @@ class SailConfig:
                 default_query_evaluation_mode
             )
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the SAIL configuration to the RDF graph.
 
@@ -418,28 +437,45 @@ class SailConfig:
             The RDF node representing this configuration.
         """
         sail_node = BNode()
-        graph.add((sail_node, CONFIG["sail.type"], Literal(self.sail_type)))
+        graph.add(Quad(sail_node, CONFIG["sail.type"], Literal(self.sail_type), None))
         for key, value in self.config_params.items():
             if isinstance(value, str):
-                graph.add((sail_node, CONFIG[key], Literal(value)))
-            elif isinstance(value, int):
+                graph.add(Quad(sail_node, CONFIG[key], Literal(value), None))
+            elif isinstance(value, bool):
                 graph.add(
-                    (sail_node, CONFIG[key], Literal(value, datatype=XSD.integer))
+                    Quad(
+                        sail_node,
+                        CONFIG[key],
+                        Literal(str(value).lower(), datatype=XSD["boolean"]),
+                        None,
+                    )
+                )
+            elif isinstance(value, int) and not isinstance(value, bool):
+                graph.add(
+                    Quad(
+                        sail_node,
+                        CONFIG[key],
+                        Literal(str(value), datatype=XSD["integer"]),
+                        None,
+                    )
                 )
             elif isinstance(value, float):
-                graph.add((sail_node, CONFIG[key], Literal(value, datatype=XSD.double)))
-            elif isinstance(value, bool):
                 graph.add(
-                    (sail_node, CONFIG[key], Literal(value, datatype=XSD.boolean))
+                    Quad(
+                        sail_node,
+                        CONFIG[key],
+                        Literal(str(value), datatype=XSD["double"]),
+                        None,
+                    )
                 )
             elif isinstance(value, list):
                 for item in value:
-                    graph.add((sail_node, CONFIG[key], URIRef(item)))
+                    graph.add(Quad(sail_node, CONFIG[key], URIRef(item), None))
             elif isinstance(value, SailConfig) or isinstance(
                 value, RepositoryImplConfig
             ):
                 nested_node = value.add_to_graph(graph)
-                graph.add((sail_node, CONFIG[key], nested_node))
+                graph.add(Quad(sail_node, CONFIG[key], nested_node, None))
             else:
                 raise ValueError(f"Unsupported configuration value type: {type(value)}")
         return sail_node
@@ -447,7 +483,7 @@ class SailConfig:
 
 class MemoryStoreConfig(SailConfig):
     """
-    Configuration for a MemoryStore using RDFlib.
+    Configuration for a MemoryStore using .
     """
 
     TYPE = "openrdf:MemoryStore"
@@ -543,7 +579,7 @@ class MemoryStoreConfig(SailConfig):
 
 class NativeStoreConfig(SailConfig):
     """
-    Configuration for a NativeStore using RDFlib.
+    Configuration for a NativeStore using .
     """
 
     TYPE = "openrdf:NativeStore"
@@ -711,7 +747,7 @@ class NativeStoreConfig(SailConfig):
 
 class ElasticsearchStoreConfig(SailConfig):
     """
-    Configuration for an ElasticsearchStore using RDFlib.
+    Configuration for an ElasticsearchStore using .
     """
 
     TYPE = "rdf4j:ElasticsearchStore"
@@ -835,7 +871,7 @@ class ElasticsearchStoreConfig(SailConfig):
 
 class SchemaCachingRDFSInferencerConfig(SailConfig):
     """
-    Configuration for the RDF Schema inferencer using RDFlib.
+    Configuration for the RDF Schema inferencer using .
     """
 
     TYPE = "rdf4j:SchemaCachingRDFSInferencer"
@@ -861,7 +897,7 @@ class SchemaCachingRDFSInferencerConfig(SailConfig):
         )
         self.config_params["delegate"] = delegate
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the SchemaCachingRDFSInferencer configuration to the RDF graph.
 
@@ -873,7 +909,7 @@ class SchemaCachingRDFSInferencerConfig(SailConfig):
         """
         sail_node = super().add_to_graph(graph)
         delegate_node = self.config_params["delegate"].to_rdf(graph)
-        graph.add((sail_node, CONFIG.delegate, delegate_node))
+        graph.add(Quad(sail_node, CONFIG.delegate, delegate_node, None))
         return sail_node
 
     class Builder:
@@ -928,7 +964,7 @@ class SchemaCachingRDFSInferencerConfig(SailConfig):
 
 class DirectTypeHierarchyInferencerConfig(SailConfig):
     """
-    Configuration for the Direct Type inferencer using RDFlib.
+    Configuration for the Direct Type inferencer using .
     """
 
     TYPE = "openrdf:DirectTypeHierarchyInferencer"
@@ -954,7 +990,7 @@ class DirectTypeHierarchyInferencerConfig(SailConfig):
         )
         self.config_params["delegate"] = delegate
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the DirectTypeHierarchyInferencerConfig to the graph
 
@@ -966,7 +1002,7 @@ class DirectTypeHierarchyInferencerConfig(SailConfig):
         """
         sail_node = super().add_to_graph(graph)
         delegate_node = self.config_params["delegate"].to_rdf(graph)
-        graph.add((sail_node, CONFIG["delegate"], delegate_node))
+        graph.add(Quad(sail_node, CONFIG["delegate"], delegate_node, None))
         return sail_node
 
     class Builder:
@@ -1027,7 +1063,7 @@ class DirectTypeHierarchyInferencerConfig(SailConfig):
 
 class SHACLSailConfig(SailConfig):
     """
-    Configuration for the SHACL Sail using RDFlib.
+    Configuration for the SHACL Sail using .
     """
 
     TYPE = "rdf4j:ShaclSail"
@@ -1127,7 +1163,7 @@ class SHACLSailConfig(SailConfig):
                 validation_results_limit_per_constraint
             )
 
-    def add_to_graph(self, graph: Graph) -> URIRef:
+    def add_to_graph(self, graph: Dataset) -> URIRef:
         """
         Adds the SHACLSailConfig to the RDF graph.
 
@@ -1139,21 +1175,38 @@ class SHACLSailConfig(SailConfig):
         """
         sail_node = super().add_to_graph(graph)  # Get the basic node
         delegate_node = self.config_params["delegate"].to_rdf(graph)
-        graph.add((sail_node, CONFIG.delegate, delegate_node))
+        graph.add(Quad(sail_node, CONFIG.delegate, delegate_node, None))
 
         # Add SHACL-specific parameters
         for key, value in self.config_params.items():
             if key != "delegate":  # Delegate is already handled
                 if isinstance(value, bool):
                     graph.add(
-                        (sail_node, CONFIG[key], Literal(value, datatype=XSD.boolean))
+                        Quad(
+                            sail_node,
+                            CONFIG[key],
+                            Literal(str(value).lower(), datatype=XSD["boolean"]),
+                            None,
+                        )
                     )
-                elif isinstance(value, int):
+                elif isinstance(value, int) and not isinstance(value, bool):
                     graph.add(
-                        (sail_node, CONFIG[key], Literal(value, datatype=XSD.integer))
+                        Quad(
+                            sail_node,
+                            CONFIG[key],
+                            Literal(str(value), datatype=XSD["integer"]),
+                            None,
+                        )
                     )
                 else:
-                    graph.add((sail_node, CONFIG[key], Literal(value)))
+                    graph.add(
+                        Quad(
+                            sail_node,
+                            CONFIG[key],
+                            Literal(value),
+                            None,
+                        )
+                    )
         return sail_node
 
     class Builder:

rdf4j_python/model/term.py

@@ -1,14 +1,20 @@
-from typing import Optional, Tuple, TypeAlias
+from typing import TypeAlias
 
-from rdflib import URIRef as _URIRef
-from rdflib.term import IdentifiedNode, Node
+import pyoxigraph as og
 
-IRI: TypeAlias = _URIRef
+IRI: TypeAlias = og.NamedNode
+BlankNode: TypeAlias = og.BlankNode
+Literal: TypeAlias = og.Literal
+DefaultGraph: TypeAlias = og.DefaultGraph
+Variable: TypeAlias = og.Variable
 
+Quad: TypeAlias = og.Quad
+Triple: TypeAlias = og.Triple
 
-Subject: TypeAlias = Node
-Predicate: TypeAlias = Node
-Object: TypeAlias = Node
-Context: TypeAlias = Optional[IdentifiedNode]
+Subject: TypeAlias = IRI | BlankNode | Triple
+Predicate: TypeAlias = IRI
+Object: TypeAlias = IRI | BlankNode | Literal
+Context: TypeAlias = IRI | BlankNode | DefaultGraph | None
 
-RDFStatement: TypeAlias = Tuple[Subject, Predicate, Object, Context]
+
+QuadResultSet: TypeAlias = og.QuadParser

rdf4j_python/model/vocabulary.py

@@ -4,3 +4,4 @@ from rdf4j_python.model import Namespace
 RDF = Namespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
 RDFS = Namespace("rdfs", "http://www.w3.org/2000/01/rdf-schema#")
 EXAMPLE = Namespace("ex", "http://example.org/")
+XSD = Namespace("xsd", "http://www.w3.org/2001/XMLSchema#")

rdf4j_python/utils/helpers.py

@@ -1,22 +1,20 @@
+from io import BytesIO
 from typing import Iterable
 
-from rdf4j_python.model.term import RDFStatement
+import pyoxigraph as og
 
+from rdf4j_python.model.term import Quad, Triple
 
-def serialize_statements(statements: Iterable[RDFStatement]) -> str:
+
+def serialize_statements(statements: Iterable[Quad] | Iterable[Triple]) -> bytes:
     """Serializes statements to RDF data.
 
     Args:
-        statements (Iterable[RDFStatement]): RDF statements.
+        statements (Iterable[Quad] | Iterable[Triple]): RDF statements.
 
     Returns:
-        str: Serialized RDF data.
+        bytes: Serialized RDF data.
     """
-    lines = []
-    for subj, pred, obj, ctx in statements:
-        parts = [subj.n3(), pred.n3(), obj.n3()]
-        if ctx:
-            parts.append(ctx.n3())
-        parts.append(".")
-        lines.append(" ".join(parts))
-    return "\n".join(lines) + "\n"
+    io = BytesIO()
+    og.serialize(statements, output=io, format=og.RdfFormat.N_QUADS)
+    return io.getvalue()

{rdf4j_python-0.1.2.dist-info → rdf4j_python-0.1.4.dist-info}/METADATA

@@ -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.4.dist-info/RECORD

@@ -0,0 +1,23 @@
+rdf4j_python/__init__.py,sha256=E8gojaWuLHo2AfNn5HBc5cF7K8_dK2jOBcZaH_qoZs4,347
+rdf4j_python/_client/__init__.py,sha256=L5q5RTHXCNyHp2WNP4xTemGXNntUW4RF_QJPoCWciUQ,98
+rdf4j_python/_client/_client.py,sha256=JfHFudRDVkzmb_jWx1u2meqqFONImBQHuaoYkb4mWPc,7390
+rdf4j_python/_driver/__init__.py,sha256=au0r15mQBVaJkqBknw9CoVswe7_rPPFs1wFWI_ttdy4,224
+rdf4j_python/_driver/_async_named_graph.py,sha256=BqJRpN-JzGpvlSnWY2RrM5TrnIHg6W4PortZ0y-4mgw,2685
+rdf4j_python/_driver/_async_rdf4j_db.py,sha256=POJ2-5EiyFOjX6ykjxbm0RH7yjtU6mXCY2PlVYidLDI,4497
+rdf4j_python/_driver/_async_repository.py,sha256=sW52MvZfbPeqJciFk4bgTHcDpxlZpXSikEsYflAmYHQ,15251
+rdf4j_python/exception/__init__.py,sha256=PFdUyIMsHIL5e2P2z33Qr2pwlUAJVI0G5T8114W4-1A,83
+rdf4j_python/exception/repo_exception.py,sha256=WXlfIYzOYfNU8LpwtOct9fAZADR-P3cZx4jAX9v_HaA,704
+rdf4j_python/model/__init__.py,sha256=wHboqZX2bN3AubXvWRwKOWwnrefpeiiB_nnry2Ba_a4,176
+rdf4j_python/model/_namespace.py,sha256=6iOvPc2Z6XFY44wmVucQCrjZbFuxdBtoTfDq_bSHJS0,3854
+rdf4j_python/model/_repository_info.py,sha256=fdKwjoQz6_D95Q8uZEuEYhXEUeqElsdBkHRCRRNxjzM,2010
+rdf4j_python/model/repository_config.py,sha256=6s-b0NPVILOLbmhAdTYR2xia7ErACvWvCUrAYcvZZng,56702
+rdf4j_python/model/term.py,sha256=JBxndQESR2KEY6y9s6TqoELUQaegKcIUO0ctR818QaA,508
+rdf4j_python/model/vocabulary.py,sha256=Yam0F_YNlO-7wDi2fc0DkAqIKB4ZqCpqq56wKRrFAcw,307
+rdf4j_python/utils/__init__.py,sha256=LAyzkmO5QOIjJogQE1m4Eszwb2cCU8ytKRfhjAGoraw,34
+rdf4j_python/utils/const.py,sha256=HKH9ZGe7m_dvMx1RwT6zhu2HUkvwOX2Y4e8vQFs3uE8,849
+rdf4j_python/utils/helpers.py,sha256=4ubvrx3OV_0Y2_YECNIJhkJUB-JthdCJA8d6Hz_G_kE,506
+rdf4j_python-0.1.4.dist-info/licenses/LICENSE,sha256=sGjA7CzoCG1LVlkh0ZB76ZdgWHVpUFegLU41YYDkGIA,1499
+rdf4j_python-0.1.4.dist-info/METADATA,sha256=wdaugJ9Oxn4-fgfwifMaIlK3bplUxHJan54ciVAtZKo,3011
+rdf4j_python-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rdf4j_python-0.1.4.dist-info/top_level.txt,sha256=Lf2K8d8WcEkmvo5giLGuZ3gl20rNEwMssyAFBeVzbCs,13
+rdf4j_python-0.1.4.dist-info/RECORD,,

{rdf4j_python-0.1.2.dist-info → rdf4j_python-0.1.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

rdf4j_python/model/_base_model.py

@@ -1,48 +0,0 @@
-from abc import ABC
-from typing import Mapping, Optional
-
-from rdflib.term import Identifier, Literal, URIRef, Variable
-
-
-class _BaseModel(ABC):
-    """Abstract base class providing utility methods for parsing RDF query results."""
-
-    @staticmethod
-    def get_literal(
-        result: Mapping[Variable, Identifier],
-        var_name: str,
-        default: Optional[str] = None,
-    ) -> Optional[str]:
-        """
-        Extracts a literal value from a SPARQL query result.
-
-        Args:
-            result (Mapping[Variable, Identifier]): A mapping of variable bindings from a query result.
-            var_name (str): The variable name to extract.
-            default (Optional[str], optional): The value to return if the variable is not found or is not a Literal. Defaults to None.
-
-        Returns:
-            Optional[str]: The Python representation of the literal, or the default value.
-        """
-        val = result.get(Variable(var_name))
-        return val.toPython() if isinstance(val, Literal) else default
-
-    @staticmethod
-    def get_uri(
-        result: Mapping[Variable, Identifier],
-        var_name: str,
-        default: Optional[str] = None,
-    ) -> Optional[str]:
-        """
-        Extracts a URI value from a SPARQL query result.
-
-        Args:
-            result (Mapping[Variable, Identifier]): A mapping of variable bindings from a query result.
-            var_name (str): The variable name to extract.
-            default (Optional[str], optional): The value to return if the variable is not found or is not a URIRef. Defaults to None.
-
-        Returns:
-            Optional[str]: The URI string, or the default value.
-        """
-        val = result.get(Variable(var_name))
-        return str(val) if isinstance(val, URIRef) else default

rdf4j_python/model/_dataset.py

@@ -1,38 +0,0 @@
-from rdflib import Dataset as _Dataset
-
-from rdf4j_python.model.term import IRI
-
-
-class RDF4JDataSet(_Dataset):
-    """
-    An RDFLib Dataset subclass with RDF4J-specific utility methods.
-    """
-
-    def as_list(self) -> list[tuple]:
-        """
-        Converts all quads in the dataset to a list of 4-tuples.
-
-        Replaces the RDF4J default context IRI ("urn:x-rdflib:default") with None.
-
-        Returns:
-            list[tuple]: A list of (subject, predicate, object, context) quads.
-        """
-        return [
-            (s, p, o, ctx if ctx != IRI("urn:x-rdflib:default") else None)
-            for s, p, o, ctx in self.quads((None, None, None, None))
-        ]
-
-    @staticmethod
-    def from_raw_text(text: str) -> "RDF4JDataSet":
-        """
-        Parses a string of N-Quads RDF data into an RDF4JDataSet.
-
-        Args:
-            text (str): The RDF data in N-Quads format.
-
-        Returns:
-            RDF4JDataSet: A populated dataset.
-        """
-        ds = RDF4JDataSet()
-        ds.parse(data=text, format="nquads")
-        return ds

rdf4j_python-0.1.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-rdf4j_python/__init__.py,sha256=E8gojaWuLHo2AfNn5HBc5cF7K8_dK2jOBcZaH_qoZs4,347
-rdf4j_python/_client/__init__.py,sha256=L5q5RTHXCNyHp2WNP4xTemGXNntUW4RF_QJPoCWciUQ,98
-rdf4j_python/_client/_client.py,sha256=JfHFudRDVkzmb_jWx1u2meqqFONImBQHuaoYkb4mWPc,7390
-rdf4j_python/_driver/__init__.py,sha256=au0r15mQBVaJkqBknw9CoVswe7_rPPFs1wFWI_ttdy4,224
-rdf4j_python/_driver/_async_named_graph.py,sha256=zpYr6x_9aI2wHH0Pj71LlCKkHFFanz7G77Tz5azXlg4,2642
-rdf4j_python/_driver/_async_rdf4j_db.py,sha256=u6r4A4_CTp4JMEswl0I5rMjsuWnMkQV_TJrvF6u9R94,4403
-rdf4j_python/_driver/_async_repository.py,sha256=NKM9IFLTNMepVCx_UeWc7h0BTxHMKfDnUcThz97pVCs,14075
-rdf4j_python/exception/__init__.py,sha256=PFdUyIMsHIL5e2P2z33Qr2pwlUAJVI0G5T8114W4-1A,83
-rdf4j_python/exception/repo_exception.py,sha256=WXlfIYzOYfNU8LpwtOct9fAZADR-P3cZx4jAX9v_HaA,704
-rdf4j_python/model/__init__.py,sha256=eUvfFEPgDsbq37eIpd_dlvjpQPGuRwkKWNfqa0c2QwM,231
-rdf4j_python/model/_base_model.py,sha256=PyhvLhaseKaFuRU70xord8EgIfO88-UVcllkuRobE14,1780
-rdf4j_python/model/_dataset.py,sha256=-nYTm8Fz1CGsLL2ykmtGEJ9Jv4u8FC2Dgl_31LeoGhM,1065
-rdf4j_python/model/_namespace.py,sha256=yaH-MjMFsUfCFadlo25MgHf9zaRbk-wkn_BgtmemVo4,3259
-rdf4j_python/model/_repository_info.py,sha256=zSL3o_QWL06xYbnpFtXIg-PqFiRbwDFPb1aiy2JufYQ,1668
-rdf4j_python/model/repository_config.py,sha256=WPXJAbZ2pM594Uh_r3zI6N1fqObSsk74ArVZTTdqPks,55012
-rdf4j_python/model/term.py,sha256=FkK8-HG6h79dAYO_qiTYTxvu8t-d5zVY5FtgJrW997o,352
-rdf4j_python/model/vocabulary.py,sha256=R9k9dzDPwRBEgwjIF6sNZh3hL41R7GZ1eSJKb8w7IaY,247
-rdf4j_python/utils/__init__.py,sha256=LAyzkmO5QOIjJogQE1m4Eszwb2cCU8ytKRfhjAGoraw,34
-rdf4j_python/utils/const.py,sha256=HKH9ZGe7m_dvMx1RwT6zhu2HUkvwOX2Y4e8vQFs3uE8,849
-rdf4j_python/utils/helpers.py,sha256=xnMB_imsybGQ2GiHvXK4wEpcs4ADiqZ4ez0yop_ko8E,577
-rdf4j_python-0.1.2.dist-info/licenses/LICENSE,sha256=sGjA7CzoCG1LVlkh0ZB76ZdgWHVpUFegLU41YYDkGIA,1499
-rdf4j_python-0.1.2.dist-info/METADATA,sha256=7V13OG7A4fxFPLcwbIUjsqUCVDwC1dlqXE5YSHw7PbU,2852
-rdf4j_python-0.1.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-rdf4j_python-0.1.2.dist-info/top_level.txt,sha256=Lf2K8d8WcEkmvo5giLGuZ3gl20rNEwMssyAFBeVzbCs,13
-rdf4j_python-0.1.2.dist-info/RECORD,,