rdf4j-python 0.1.0__tar.gz → 0.1.1a0__tar.gz

rdf4j_python-0.1.1a0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Chengxu Bian
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

rdf4j_python-0.1.1a0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: rdf4j-python
+Version: 0.1.1a0
+Summary: The Python client for RDF4J
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rdflib>=7.1.4
+Dynamic: license-file
+
+# 🐍 rdf4j-python
+
+**A Pythonic interface to the powerful Java-based [Eclipse RDF4J](https://rdf4j.org/) framework.**
+
+> ⚠️ **Note:** This project is currently under active development and considered **experimental**. Interfaces may change. Use with caution in production environments—and feel free to help shape its future!
+
+✅ **Supports both asynchronous (`async/await`) and synchronous programming styles.**
+
+## 🌐 Overview
+
+`rdf4j-python` bridges the gap between Python applications and the [Eclipse RDF4J](https://rdf4j.org/) framework, enabling seamless interaction with RDF4J repositories directly from Python. This integration allows developers to leverage RDF4J's robust capabilities for managing RDF data and executing SPARQL queries without leaving the Python ecosystem.
+
+## 🚀 Features
+
+- **Seamless Integration**: Interact with RDF4J repositories using Pythonic constructs.
+- **SPARQL Support**: Execute SPARQL queries and updates effortlessly.
+- **Repository Management**: Create, access, and manage RDF4J repositories programmatically.
+- **Data Handling**: Add and retrieve RDF triples with ease.
+- **Format Flexibility**: Support for various RDF serialization formats.
+
+## 📦 Installation
+
+Install via pip:
+
+```bash
+pip install rdf4j-python
+```
+
+## 🧪 Usage (Async)
+
+Here's a basic example of how to use `rdf4j-python` to create an in-memory sail repository
+
+```python
+from rdf4j_python import AsyncRdf4j
+from rdf4j_python.model import MemoryStoreConfig, RepositoryConfig
+from rdf4j_python.utils.const import Rdf4jContentType
+
+async with AsyncRdf4j("http://localhost:19780/rdf4j-server") as db:
+    repo_config = (
+        RepositoryConfig.builder_with_sail_repository(
+            MemoryStoreConfig.Builder().persist(False).build(),
+        )
+        .repo_id("example-repo")
+        .title("Example Repository")
+        .build()
+    )
+    await db.create_repository(
+        repository_id=repo_config.repo_id,
+        rdf_config_data=repo_config.to_turtle(),
+        content_type=Rdf4jContentType.TURTLE,
+    )
+```
+
+For more detailed examples, refer to the [examples](https://github.com/odysa/rdf4j-python/tree/main/examples) directory.
+
+## 🤝 Contributing
+
+We welcome contributions and feedback! If you'd like to help improve this project:
+
+- Fork the repo and submit a pull request
+- Open an issue for bugs, feature ideas, or discussions
+- ⭐ Star the repo if you find it useful!
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/odysa/rdf4j-python/blob/main/LICENSE) file for details.

rdf4j_python-0.1.1a0/README.md

@@ -0,0 +1,66 @@
+# 🐍 rdf4j-python
+
+**A Pythonic interface to the powerful Java-based [Eclipse RDF4J](https://rdf4j.org/) framework.**
+
+> ⚠️ **Note:** This project is currently under active development and considered **experimental**. Interfaces may change. Use with caution in production environments—and feel free to help shape its future!
+
+✅ **Supports both asynchronous (`async/await`) and synchronous programming styles.**
+
+## 🌐 Overview
+
+`rdf4j-python` bridges the gap between Python applications and the [Eclipse RDF4J](https://rdf4j.org/) framework, enabling seamless interaction with RDF4J repositories directly from Python. This integration allows developers to leverage RDF4J's robust capabilities for managing RDF data and executing SPARQL queries without leaving the Python ecosystem.
+
+## 🚀 Features
+
+- **Seamless Integration**: Interact with RDF4J repositories using Pythonic constructs.
+- **SPARQL Support**: Execute SPARQL queries and updates effortlessly.
+- **Repository Management**: Create, access, and manage RDF4J repositories programmatically.
+- **Data Handling**: Add and retrieve RDF triples with ease.
+- **Format Flexibility**: Support for various RDF serialization formats.
+
+## 📦 Installation
+
+Install via pip:
+
+```bash
+pip install rdf4j-python
+```
+
+## 🧪 Usage (Async)
+
+Here's a basic example of how to use `rdf4j-python` to create an in-memory sail repository
+
+```python
+from rdf4j_python import AsyncRdf4j
+from rdf4j_python.model import MemoryStoreConfig, RepositoryConfig
+from rdf4j_python.utils.const import Rdf4jContentType
+
+async with AsyncRdf4j("http://localhost:19780/rdf4j-server") as db:
+    repo_config = (
+        RepositoryConfig.builder_with_sail_repository(
+            MemoryStoreConfig.Builder().persist(False).build(),
+        )
+        .repo_id("example-repo")
+        .title("Example Repository")
+        .build()
+    )
+    await db.create_repository(
+        repository_id=repo_config.repo_id,
+        rdf_config_data=repo_config.to_turtle(),
+        content_type=Rdf4jContentType.TURTLE,
+    )
+```
+
+For more detailed examples, refer to the [examples](https://github.com/odysa/rdf4j-python/tree/main/examples) directory.
+
+## 🤝 Contributing
+
+We welcome contributions and feedback! If you'd like to help improve this project:
+
+- Fork the repo and submit a pull request
+- Open an issue for bugs, feature ideas, or discussions
+- ⭐ Star the repo if you find it useful!
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/odysa/rdf4j-python/blob/main/LICENSE) file for details.

{rdf4j_python-0.1.0 → rdf4j_python-0.1.1a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rdf4j-python"
-version = "0.1.0"
+version = "0.1.1a"
 description = "The Python client for RDF4J"
 readme = "README.md"
 requires-python = ">=3.10"

{rdf4j_python-0.1.0 → rdf4j_python-0.1.1a0}/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-0.1.1a0/rdf4j_python/_driver/__init__.py

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

{rdf4j_python-0.1.0 → rdf4j_python-0.1.1a0}/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-0.1.1a0/rdf4j_python/_driver/_async_repository.py

@@ -0,0 +1,109 @@
+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 AsyncRdf4JRepository:
+    def __init__(self, client: AsyncApiClient, repository_id: str):
+        self._client = client
+        self._repository_id = repository_id
+
+    async def query(
+        self,
+        sparql_query: str,
+        infer: bool = True,
+        accept: Rdf4jContentType = Rdf4jContentType.SPARQL_RESULTS_JSON,
+    ):
+        path = f"/repositories/{self._repository_id}"
+        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
+
+    async def update(self, sparql_update: str):
+        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(
+        self, rdf_data: str, content_type: Rdf4jContentType = Rdf4jContentType.TURTLE
+    ):
+        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"
+        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, 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-0.1.1a0/rdf4j_python/exception/repo_exception.py

@@ -0,0 +1,13 @@
+class RepositoryCreationException(Exception): ...
+
+
+class RepositoryDeletionException(Exception): ...
+
+
+class NamespaceException(Exception): ...
+
+
+class RepositoryNotFoundException(Exception): ...
+
+
+class RepositoryInternalException(Exception): ...

rdf4j_python-0.1.1a0/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-0.1.1a0/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