rdf4j-python 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

rdf4j_python/_client/_client.py

@@ -42,6 +42,17 @@ class BaseClient:
 class SyncApiClient(BaseClient):
     """Synchronous API client using httpx.Client."""
 
+    def __init__(self, base_url: str, timeout: int = 10):
+        """
+        Initializes the SyncApiClient.
+
+        Args:
+            base_url (str): The base URL for the API endpoints.
+            timeout (int, optional): Request timeout in seconds. Defaults to 10.
+        """
+        super().__init__(base_url, timeout)
+        self.client = httpx.Client(timeout=self.timeout)
+
     def __enter__(self):
         """
         Enters the context and initializes the HTTP client.
@@ -49,7 +60,7 @@ class SyncApiClient(BaseClient):
         Returns:
             SyncApiClient: The instance of the client.
         """
-        self.client = httpx.Client(timeout=self.timeout).__enter__()
+        self.client.__enter__()
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
@@ -142,6 +153,17 @@ class SyncApiClient(BaseClient):
 class AsyncApiClient(BaseClient):
     """Asynchronous API client using httpx.AsyncClient."""
 
+    def __init__(self, base_url: str, timeout: int = 10):
+        """
+        Initializes the AsyncApiClient.
+
+        Args:
+            base_url (str): The base URL for the API endpoints.
+            timeout (int, optional): Request timeout in seconds. Defaults to 10.
+        """
+        super().__init__(base_url, timeout)
+        self.client = httpx.AsyncClient(timeout=self.timeout)
+
     async def __aenter__(self):
         """
         Enters the async context and initializes the HTTP client.
@@ -149,7 +171,7 @@ class AsyncApiClient(BaseClient):
         Returns:
             AsyncApiClient: The instance of the client.
         """
-        self.client = await httpx.AsyncClient(timeout=self.timeout).__aenter__()
+        await self.client.__aenter__()
         return self
 
     async def __aexit__(self, exc_type, exc_value, traceback):

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/_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,16 @@ class AsyncRdf4JRepository:
             RepositoryNotFoundException: If the repository doesn't exist.
             httpx.HTTPStatusError: If the update fails.
         """
+        # SPARQL UPDATE operations return HTTP 204 No Content on success.
+        # No result data is returned as per SPARQL 1.1 UPDATE specification.
         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 +128,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