rdf4j-python 0.1.0__py3-none-any.whl → 0.1.1a0__py3-none-any.whl

rdf4j_python/__init__.py

@@ -1,9 +1,9 @@
 from ._client import AsyncApiClient, SyncApiClient
-from ._driver import AsyncRdf4jDB, AsyncRepository
+from ._driver import AsyncRdf4j, AsyncRdf4JRepository
 
 __all__ = [
     "AsyncApiClient",
     "SyncApiClient",
-    "AsyncRdf4jDB",
-    "AsyncRepository",
+    "AsyncRdf4j",
+    "AsyncRdf4JRepository",
 ]

rdf4j_python/_driver/__init__.py

@@ -1,7 +1,7 @@
-from ._async_rdf4j_db import AsyncRdf4jDB
-from ._async_repository import AsyncRepository
+from ._async_rdf4j_db import AsyncRdf4j
+from ._async_repository import AsyncRdf4JRepository
 
 __all__ = [
-    "AsyncRdf4jDB",
-    "AsyncRepository",
+    "AsyncRdf4j",
+    "AsyncRdf4JRepository",
 ]

rdf4j_python/_driver/_async_rdf4j_db.py

@@ -8,13 +8,13 @@ from rdf4j_python.exception.repo_exception import (
     RepositoryCreationException,
     RepositoryDeletionException,
 )
-from rdf4j_python.model.repository import RepositoryInfo
+from rdf4j_python.model._repository_info import RepositoryMetadata
 from rdf4j_python.utils.const import Rdf4jContentType
 
-from ._async_repository import AsyncRepository
+from ._async_repository import AsyncRdf4JRepository
 
 
-class AsyncRdf4jDB:
+class AsyncRdf4j:
     _client: AsyncApiClient
     _base_url: str
 
@@ -33,7 +33,7 @@ class AsyncRdf4jDB:
         response.raise_for_status()
         return response.text
 
-    async def list_repositories(self) -> list[RepositoryInfo]:
+    async def list_repositories(self) -> list[RepositoryMetadata]:
         """
         List all RDF4J repositories.
 
@@ -48,24 +48,25 @@ class AsyncRdf4jDB:
         )
 
         return [
-            RepositoryInfo.from_rdflib_binding(binding) for binding in result.bindings
+            RepositoryMetadata.from_rdflib_binding(binding)
+            for binding in result.bindings
         ]
 
-    async def get_repository(self, repository_id: str) -> AsyncRepository:
+    async def get_repository(self, repository_id: str) -> AsyncRdf4JRepository:
         """
         Get an AsyncRepository instance for the specified repository ID.
 
         :param repository_id: The ID of the repository.
         :return: An instance of AsyncRepository.
         """
-        return AsyncRepository(self._client, repository_id)
+        return AsyncRdf4JRepository(self._client, repository_id)
 
     async def create_repository(
         self,
         repository_id: str,
         rdf_config_data: str,
         content_type: Union[Rdf4jContentType, str] = Rdf4jContentType.TURTLE,
-    ):
+    ) -> AsyncRdf4JRepository:
         """
         Create a new RDF4J repository.
 
@@ -86,6 +87,7 @@ class AsyncRdf4jDB:
             raise RepositoryCreationException(
                 f"Repository creation failed: {response.status_code} - {response.text}"
             )
+        return AsyncRdf4JRepository(self._client, repository_id)
 
     async def delete_repository(self, repository_id: str):
         """

rdf4j_python/_driver/_async_repository.py

@@ -1,8 +1,17 @@
+import httpx
+import rdflib
+
 from rdf4j_python import AsyncApiClient
+from rdf4j_python.exception.repo_exception import (
+    NamespaceException,
+    RepositoryInternalException,
+    RepositoryNotFoundException,
+)
+from rdf4j_python.model._namespace import Namespace
 from rdf4j_python.utils.const import Rdf4jContentType
 
 
-class AsyncRepository:
+class AsyncRdf4JRepository:
     def __init__(self, client: AsyncApiClient, repository_id: str):
         self._client = client
         self._repository_id = repository_id
@@ -17,6 +26,7 @@ class AsyncRepository:
         params = {"query": sparql_query, "infer": str(infer).lower()}
         headers = {"Accept": accept.value}
         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
@@ -25,6 +35,7 @@ class AsyncRepository:
         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)
+        self._handle_repo_not_found_exception(response)
         response.raise_for_status()
 
     async def replace_statements(
@@ -33,19 +44,66 @@ class AsyncRepository:
         path = f"/repositories/{self._repository_id}/statements"
         headers = {"Content-Type": content_type.value}
         response = await self._client.put(path, data=rdf_data, headers=headers)
+        self._handle_repo_not_found_exception(response)
         response.raise_for_status()
 
     async def get_namespaces(self):
         path = f"/repositories/{self._repository_id}/namespaces"
-        response = await self._client.get(path)
-        if Rdf4jContentType.SPARQL_RESULTS_JSON in response.headers.get(
-            "Content-Type", ""
-        ):
-            return response.json()
-        return response.text
+        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):
         path = f"/repositories/{self._repository_id}/namespaces/{prefix}"
         headers = {"Content-Type": Rdf4jContentType.NTRIPLES.value}
-        response = await self._client.put(path, data=namespace, headers=headers)
+        response = await self._client.put(path, content=namespace, 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}")
+
+    async def get_namespace(self, prefix: str) -> Namespace:
+        path = f"/repositories/{self._repository_id}/namespaces/{prefix}"
+        headers = {"Accept": Rdf4jContentType.NTRIPLES.value}
+        response = await self._client.get(path, headers=headers)
+        self._handle_repo_not_found_exception(response)
+
+        if response.status_code != httpx.codes.OK:
+            raise NamespaceException(f"Failed to get namespace: {response.text}")
+
+        return Namespace(prefix, response.text)
+
+    async def delete_namespace(self, prefix: str):
+        path = f"/repositories/{self._repository_id}/namespaces/{prefix}"
+        response = await self._client.delete(path)
+        self._handle_repo_not_found_exception(response)
+        response.raise_for_status()
+
+    async def size(self) -> int:
+        path = f"/repositories/{self._repository_id}/size"
+        response = await self._client.get(path)
+        self._handle_repo_not_found_exception(response)
+
+        if response.status_code != httpx.codes.OK:
+            raise RepositoryInternalException(f"Failed to get size: {response.text}")
+
+        return int(response.text.strip())
+
+    async def add_statement(self, subject: str, predicate: str, object: str):
+        path = f"/repositories/{self._repository_id}/statements"
+        headers = {"Content-Type": Rdf4jContentType.NTRIPLES.value}
+        response = await self._client.post(
+            path, data=f"{subject} {predicate} {object}.", headers=headers
+        )
+        self._handle_repo_not_found_exception(response)
         response.raise_for_status()
+
+    def _handle_repo_not_found_exception(self, response: httpx.Response):
+        if response.status_code == httpx.codes.NOT_FOUND:
+            raise RepositoryNotFoundException(
+                f"Repository {self._repository_id} not found"
+            )

rdf4j_python/exception/repo_exception.py

@@ -2,3 +2,12 @@ class RepositoryCreationException(Exception): ...
 
 
 class RepositoryDeletionException(Exception): ...
+
+
+class NamespaceException(Exception): ...
+
+
+class RepositoryNotFoundException(Exception): ...
+
+
+class RepositoryInternalException(Exception): ...

rdf4j_python/model/__init__.py

@@ -0,0 +1,16 @@
+from ._namespace import IRI, Namespace
+from ._repository_config import (
+    MemoryStoreConfig,
+    NativeStoreConfig,
+    RepositoryConfig,
+)
+from ._repository_info import RepositoryMetadata
+
+__all__ = [
+    "IRI",
+    "Namespace",
+    "RepositoryConfig",
+    "MemoryStoreConfig",
+    "NativeStoreConfig",
+    "RepositoryMetadata",
+]

rdf4j_python/model/_namespace.py

@@ -0,0 +1,56 @@
+from typing import Mapping
+
+from rdflib import URIRef
+from rdflib.namespace import Namespace as RdflibNamespace
+from rdflib.term import Identifier, Variable
+
+from ._base_model import _BaseModel
+
+
+class IRI(URIRef): ...
+
+
+class Namespace:
+    _prefix: str
+    _namespace: RdflibNamespace
+
+    def __init__(self, prefix: str, namespace: str):
+        self._prefix = prefix
+        self._namespace = RdflibNamespace(namespace)
+
+    @classmethod
+    def from_rdflib_binding(cls, binding: Mapping[Variable, Identifier]) -> "Namespace":
+        prefix = _BaseModel.get_literal(binding, "prefix", "")
+        namespace = _BaseModel.get_literal(binding, "namespace", "")
+        return cls(
+            prefix=prefix,
+            namespace=namespace,
+        )
+
+    def __str__(self):
+        return f"{self._prefix}: {self._namespace}"
+
+    def __repr__(self):
+        return f"Namespace(prefix={self._prefix}, namespace={self._namespace})"
+
+    def __contains__(self, item: str) -> bool:
+        return item in self._namespace
+
+    def term(self, name: str) -> IRI:
+        return IRI(self._namespace.term(name))
+
+    def __getitem__(self, item: str) -> IRI:
+        return self.term(item)
+
+    def __getattr__(self, item: str) -> IRI:
+        if item.startswith("__"):
+            raise AttributeError
+        return self.term(item)
+
+    @property
+    def namespace(self) -> IRI:
+        return IRI(self._namespace)
+
+    @property
+    def prefix(self) -> str:
+        return self._prefix