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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdf4j-python
-Version: 0.1.3
+Version: 0.1.4
 Summary: The Python client for RDF4J
 Author-email: Chengxu Bian <cbian564@gmail.com>
 Requires-Python: >=3.10
@@ -8,6 +8,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.28.1
 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.3 → 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.3 → rdf4j_python-0.1.4}/pyproject.toml

@@ -1,18 +1,22 @@
 [project]
 name = "rdf4j-python"
 authors = [{ name = "Chengxu Bian", email = "cbian564@gmail.com" }]
-version = "0.1.3"
+version = "0.1.4"
 description = "The Python client for RDF4J"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = ["httpx>=0.28.1", "pyoxigraph>=0.4.10"]
 
+[project.optional-dependencies]
+sparqlwrapper = ["sparqlwrapper>=2.0.0"]
+
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",
     "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"]
 

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

@@ -69,6 +69,7 @@ class AsyncRdf4j:
         query_solutions = og.parse_query_results(
             response.text, format=og.QueryResultsFormat.JSON
         )
+        assert isinstance(query_solutions, og.QuerySolutions)
         return [
             RepositoryMetadata.from_sparql_query_solution(query_solution)
             for query_solution in query_solutions

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

@@ -25,10 +25,21 @@ from rdf4j_python.model.term import (
 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}
+        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.
@@ -97,6 +127,7 @@ class AsyncRdf4JRepository:
         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

{rdf4j_python-0.1.3 → rdf4j_python-0.1.4}/rdf4j_python/model/repository_config.py

@@ -59,12 +59,12 @@ class RepositoryConfig:
         """
         return self._title
 
-    def to_turtle(self) -> str:
+    def to_turtle(self) -> bytes | None:
         """
         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.
 
@@ -909,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:
@@ -1002,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:
@@ -1175,7 +1175,7 @@ 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():

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdf4j-python
-Version: 0.1.3
+Version: 0.1.4
 Summary: The Python client for RDF4J
 Author-email: Chengxu Bian <cbian564@gmail.com>
 Requires-Python: >=3.10
@@ -8,6 +8,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.28.1
 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/rdf4j_python.egg-info/requires.txt

@@ -0,0 +1,5 @@
+httpx>=0.28.1
+pyoxigraph>=0.4.10
+
+[sparqlwrapper]
+sparqlwrapper>=2.0.0

{rdf4j_python-0.1.3 → rdf4j_python-0.1.4}/tests/test_rdf4j_repository.py

@@ -4,10 +4,12 @@ from rdf4j_python import AsyncRdf4JRepository
 from rdf4j_python.exception.repo_exception import (
     NamespaceException,
     RepositoryNotFoundException,
+    RepositoryUpdateException,
 )
 from rdf4j_python.model.term import Literal, Quad, QuadResultSet, Triple
 from rdf4j_python.model.vocabulary import EXAMPLE as ex
 from rdf4j_python.model.vocabulary import RDF, RDFS
+from rdf4j_python.utils.const import Rdf4jContentType
 
 ex_ns = ex.namespace
 rdf_ns = RDF.namespace
@@ -257,3 +259,130 @@ async def test_repo_replace_statements_contexts(mem_repo: AsyncRdf4JRepository):
     assert new_statement_2 in resultSet
     assert old_statement_1 not in resultSet
     assert old_statement_2 not in resultSet
+
+
+@pytest.mark.asyncio
+async def test_repo_query_simple_select(mem_repo: AsyncRdf4JRepository):
+    await mem_repo.add_statements(
+        [
+            Triple(ex["subject1"], ex["predicate"], Literal("test_object")),
+            Triple(ex["subject2"], ex["predicate"], Literal("test_object2")),
+        ]
+    )
+    result = await mem_repo.query("SELECT * WHERE { ?s ?p ?o }")
+    result_list = list(result)
+    assert len(result_list) == 2
+    assert result_list[0]["s"] == ex["subject1"]
+    assert result_list[0]["p"] == ex["predicate"]
+    assert result_list[0]["o"] == Literal("test_object")
+    assert result_list[1]["s"] == ex["subject2"]
+    assert result_list[1]["p"] == ex["predicate"]
+    assert result_list[1]["o"] == Literal("test_object2")
+
+
+@pytest.mark.asyncio
+async def test_repo_query_simple_select_with_filter(mem_repo: AsyncRdf4JRepository):
+    await mem_repo.add_statements(
+        [
+            Triple(ex["subject1"], ex["predicate"], Literal("test_object")),
+            Triple(ex["subject2"], ex["predicate"], Literal("test_object2")),
+        ]
+    )
+    result = await mem_repo.query(
+        "SELECT * WHERE { ?s ?p ?o FILTER(?o = 'test_object') }"
+    )
+    result_list = list(result)
+    assert len(result_list) == 1
+    assert result_list[0]["s"] == ex["subject1"]
+    assert result_list[0]["p"] == ex["predicate"]
+    assert result_list[0]["o"] == Literal("test_object")
+
+
+@pytest.mark.asyncio
+async def test_repo_group_by(mem_repo: AsyncRdf4JRepository):
+    await mem_repo.add_statements(
+        [
+            Triple(ex["subject1"], ex["predicate"], Literal("test_object")),
+            Triple(ex["subject2"], ex["predicate"], Literal("test_object2")),
+        ]
+    )
+    result = await mem_repo.query(
+        "SELECT ?s (COUNT(?p) AS ?count) WHERE { ?s ?p ?o } GROUP BY ?s"
+    )
+    result_list = list(result)
+    assert len(result_list) == 2
+    assert result_list[0]["count"] == Literal(1)
+    assert result_list[1]["count"] == Literal(1)
+
+
+@pytest.mark.asyncio
+async def test_repo_query_with_order_by(mem_repo: AsyncRdf4JRepository):
+    await mem_repo.add_statements(
+        [
+            Triple(ex["subject3"], ex["predicate"], Literal("test_object3")),
+            Triple(ex["subject1"], ex["predicate"], Literal("test_object1")),
+            Triple(ex["subject2"], ex["predicate"], Literal("test_object2")),
+        ]
+    )
+    result = await mem_repo.query("SELECT * WHERE { ?s ?p ?o } ORDER BY ?s")
+    result_list = list(result)
+    assert len(result_list) == 3
+    assert result_list[0]["s"] == ex["subject1"]
+    assert result_list[1]["s"] == ex["subject2"]
+    assert result_list[2]["s"] == ex["subject3"]
+
+
+@pytest.mark.asyncio
+async def test_repo_query_with_limit(mem_repo: AsyncRdf4JRepository):
+    await mem_repo.add_statements(
+        [
+            Triple(ex["subject1"], ex["predicate"], Literal("test_object1")),
+            Triple(ex["subject2"], ex["predicate"], Literal("test_object2")),
+            Triple(ex["subject3"], ex["predicate"], Literal("test_object3")),
+        ]
+    )
+    result = await mem_repo.query("SELECT * WHERE { ?s ?p ?o } LIMIT 2")
+    result_list = list(result)
+    assert len(result_list) == 2
+    assert result_list[0]["s"] == ex["subject1"]
+    assert result_list[0]["p"] == ex["predicate"]
+    assert result_list[0]["o"] == Literal("test_object1")
+    assert result_list[1]["s"] == ex["subject2"]
+    assert result_list[1]["p"] == ex["predicate"]
+    assert result_list[1]["o"] == Literal("test_object2")
+
+
+@pytest.mark.asyncio
+async def test_repo_update(mem_repo: AsyncRdf4JRepository):
+    await mem_repo.update(
+        'INSERT DATA { <http://example.org/subject1> <http://example.org/predicate> "test_object1" }',
+        Rdf4jContentType.SPARQL_UPDATE,
+    )
+    result = await mem_repo.query("SELECT * WHERE { ?s ?p ?o }")
+    result_list = list(result)
+    assert len(result_list) == 1
+    assert result_list[0]["s"] == ex["subject1"]
+    assert result_list[0]["p"] == ex["predicate"]
+    assert result_list[0]["o"] == Literal("test_object1")
+
+
+@pytest.mark.asyncio
+async def test_repo_update_not_found(rdf4j_service: str):
+    from rdf4j_python import AsyncRdf4j
+
+    async with AsyncRdf4j(rdf4j_service) as db:
+        repo = await db.get_repository("not_found")
+        with pytest.raises(RepositoryNotFoundException):
+            await repo.update(
+                "INSERT DATA { <http://example.org/subject1> <http://example.org/predicate> 'test_object1' }",
+                Rdf4jContentType.SPARQL_UPDATE,
+            )
+
+
+@pytest.mark.asyncio
+async def test_repo_update_invalid_query(mem_repo: AsyncRdf4JRepository):
+    with pytest.raises(RepositoryUpdateException):
+        await mem_repo.update(
+            "INSERT D <http://example.org/subject1> <http://example.org/predicate> 'test_object1' }",
+            Rdf4jContentType.SPARQL_UPDATE,
+        )

rdf4j_python-0.1.3/rdf4j_python.egg-info/requires.txt

@@ -1,2 +0,0 @@
-httpx>=0.28.1
-pyoxigraph>=0.4.10