rdf4j-python 0.1.0__tar.gz

rdf4j_python-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: rdf4j-python
+Version: 0.1.0
+Summary: The Python client for RDF4J
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rdflib>=7.1.4

rdf4j_python-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "rdf4j-python"
+version = "0.1.0"
+description = "The Python client for RDF4J"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.28.1", "rdflib>=7.1.4"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-asyncio>=0.26.0",
+    "pytest-docker>=3.2.1",
+    "ruff>=0.11.8",
+]
+
+[tool.pytest.ini_options]
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"

rdf4j_python-0.1.0/rdf4j_python/__init__.py

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

rdf4j_python-0.1.0/rdf4j_python/_client/__init__.py

@@ -0,0 +1,3 @@
+from ._client import AsyncApiClient, SyncApiClient
+
+__all__ = ["AsyncApiClient", "SyncApiClient"]

rdf4j_python-0.1.0/rdf4j_python/_client/_client.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+
+class BaseClient:
+    def __init__(self, base_url: str, timeout: int = 10):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _build_url(self, path: str) -> str:
+        return f"{self.base_url}/{path.lstrip('/')}"
+
+
+class SyncApiClient(BaseClient):
+    def __enter__(self):
+        self.client = httpx.Client(timeout=self.timeout).__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.client.__exit__(exc_type, exc_value, traceback)
+
+    def get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> httpx.Response:
+        return self.client.get(self._build_url(path), params=params, headers=headers)
+
+    def post(
+        self,
+        path: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> httpx.Response:
+        return self.client.post(
+            self._build_url(path), data=data, json=json, headers=headers
+        )
+
+    def put(
+        self,
+        path: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> httpx.Response:
+        return self.client.put(
+            self._build_url(path), data=data, json=json, headers=headers
+        )
+
+    def delete(
+        self, path: str, headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        return self.client.delete(self._build_url(path), headers=headers)
+
+
+class AsyncApiClient(BaseClient):
+    async def __aenter__(self):
+        self.client = await httpx.AsyncClient(timeout=self.timeout).__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.client.__aexit__(exc_type, exc_value, traceback)
+
+    async def get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> httpx.Response:
+        return await self.client.get(
+            self._build_url(path), params=params, headers=headers
+        )
+
+    async def post(
+        self,
+        path: str,
+        data: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> httpx.Response:
+        return await self.client.post(
+            self._build_url(path), data=data, json=json, headers=headers
+        )
+
+    async def put(
+        self,
+        path: str,
+        content: Optional[bytes] = None,
+        json: Optional[Any] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> httpx.Response:
+        return await self.client.put(
+            self._build_url(path), content=content, json=json, headers=headers
+        )
+
+    async def delete(
+        self, path: str, headers: Optional[Dict[str, str]] = None
+    ) -> httpx.Response:
+        return await self.client.delete(self._build_url(path), headers=headers)

rdf4j_python-0.1.0/rdf4j_python/_driver/__init__.py

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

rdf4j_python-0.1.0/rdf4j_python/_driver/_async_rdf4j_db.py

@@ -0,0 +1,101 @@
+from typing import Union
+
+import httpx
+import rdflib
+
+from rdf4j_python import AsyncApiClient
+from rdf4j_python.exception.repo_exception import (
+    RepositoryCreationException,
+    RepositoryDeletionException,
+)
+from rdf4j_python.model.repository import RepositoryInfo
+from rdf4j_python.utils.const import Rdf4jContentType
+
+from ._async_repository import AsyncRepository
+
+
+class AsyncRdf4jDB:
+    _client: AsyncApiClient
+    _base_url: str
+
+    def __init__(self, base_url: str):
+        self._base_url = base_url.rstrip("/")
+
+    async def __aenter__(self):
+        self._client = await AsyncApiClient(base_url=self._base_url).__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self._client.__aexit__(exc_type, exc_value, traceback)
+
+    async def get_protocol_version(self) -> str:
+        response = await self._client.get("/protocol")
+        response.raise_for_status()
+        return response.text
+
+    async def list_repositories(self) -> list[RepositoryInfo]:
+        """
+        List all RDF4J repositories.
+
+        :return: List of repository information.
+        """
+        response = await self._client.get(
+            "/repositories",
+            headers={"Accept": Rdf4jContentType.SPARQL_RESULTS_JSON},
+        )
+        result = rdflib.query.Result.parse(
+            response, format=Rdf4jContentType.SPARQL_RESULTS_JSON
+        )
+
+        return [
+            RepositoryInfo.from_rdflib_binding(binding) for binding in result.bindings
+        ]
+
+    async def get_repository(self, repository_id: str) -> AsyncRepository:
+        """
+        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)
+
+    async def create_repository(
+        self,
+        repository_id: str,
+        rdf_config_data: str,
+        content_type: Union[Rdf4jContentType, str] = Rdf4jContentType.TURTLE,
+    ):
+        """
+        Create a new RDF4J repository.
+
+        :param repository_id: Repository ID to create.
+        :param rdf_config_data: RDF config in Turtle, RDF/XML, etc.
+        :param content_type: MIME type of RDF config.
+        """
+        path = f"/repositories/{repository_id}"
+
+        if isinstance(content_type, Rdf4jContentType):
+            content_type = content_type.value
+        headers = {"Content-Type": content_type}
+
+        response: httpx.Response = await self._client.put(
+            path, content=rdf_config_data, headers=headers
+        )
+        if response.status_code != httpx.codes.NO_CONTENT:
+            raise RepositoryCreationException(
+                f"Repository creation failed: {response.status_code} - {response.text}"
+            )
+
+    async def delete_repository(self, repository_id: str):
+        """
+        Delete an RDF4J repository and its data/config.
+
+        :param repository_id: The repository ID to delete.
+        """
+        path = f"/repositories/{repository_id}"
+        response = await self._client.delete(path)
+        if response.status_code != httpx.codes.NO_CONTENT:
+            raise RepositoryDeletionException(
+                f"Failed to delete repository '{repository_id}': {response.status_code} - {response.text}"
+            )

rdf4j_python-0.1.0/rdf4j_python/_driver/_async_repository.py

@@ -0,0 +1,51 @@
+from rdf4j_python import AsyncApiClient
+from rdf4j_python.utils.const import Rdf4jContentType
+
+
+class AsyncRepository:
+    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)
+        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)
+        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)
+        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
+
+    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.raise_for_status()

rdf4j_python-0.1.0/rdf4j_python/exception/repo_exception.py

@@ -0,0 +1,4 @@
+class RepositoryCreationException(Exception): ...
+
+
+class RepositoryDeletionException(Exception): ...

rdf4j_python-0.1.0/rdf4j_python/model/_base_model.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Mapping, Optional
+
+from rdflib.term import Identifier, Literal, URIRef, Variable
+
+
+class _BaseModel(ABC):
+    @staticmethod
+    def get_literal(
+        result: Mapping[Variable, Identifier],
+        var_name: str,
+        default: Optional[str] = None,
+    ):
+        """Extract and convert an RDFLib Literal to a Python 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,
+    ):
+        """Extract and convert an RDFLib URIRef to a string."""
+        val = result.get(Variable(var_name))
+        return str(val) if isinstance(val, URIRef) else default

rdf4j_python-0.1.0/rdf4j_python/model/repository.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Mapping
+
+from rdflib.term import Identifier, Variable
+
+from ._base_model import _BaseModel
+
+
+@dataclass
+class RepositoryInfo(_BaseModel):
+    """
+    Represents a repository information RDF4J.
+    """
+
+    id: str  # The repository identifier
+    uri: str  # The full URI to the repository
+    title: str  # A human-readable title (currently reusing id)
+    readable: bool  # Whether the repository is readable
+    writable: bool  # Whether the repository is writable
+
+    def __str__(self):
+        # Custom string representation for easy printing
+        return f"Repository(id={self.id}, title={self.title}, uri={self.uri})"
+
+    @classmethod
+    def from_rdflib_binding(
+        cls, result: Mapping[Variable, Identifier]
+    ) -> "RepositoryInfo":
+        """
+        Create a Repository instance from a SPARQL query result
+        represented as a Mapping from rdflib Variables to Identifiers.
+        """
+
+        # Construct and return the Repository object
+        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),
+        )

rdf4j_python-0.1.0/rdf4j_python/utils/const.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+
+class Rdf4jContentType(str, Enum):
+    # SPARQL Query Results
+    SPARQL_RESULTS_JSON = "application/sparql-results+json"
+    SPARQL_RESULTS_XML = "application/sparql-results+xml"
+    SPARQL_RESULTS_BINARY = "application/x-binary-rdf-results-table"
+    BOOLEAN_TEXT = "text/boolean"
+
+    # RDF Serialization Formats
+    RDF_XML = "application/rdf+xml"
+    RDF_JSON = "application/rdf+json"
+    LD_JSON = "application/ld+json"
+    NTRIPLES = "text/plain"
+    TURTLE = "text/turtle"
+    N3 = "text/rdf+n3"
+    NQUADS = "text/x-nquads"
+    TRIG = "application/x-trig"
+    TRIX = "application/trix"
+    BINARY_RDF = "application/x-binary-rdf"
+
+    # SPARQL-specific
+    SPARQL_QUERY = "application/sparql-query"
+    SPARQL_UPDATE = "application/sparql-update"
+    FORM_URLENCODED = "application/x-www-form-urlencoded"

rdf4j_python-0.1.0/rdf4j_python.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: rdf4j-python
+Version: 0.1.0
+Summary: The Python client for RDF4J
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rdflib>=7.1.4

rdf4j_python-0.1.0/rdf4j_python.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+rdf4j_python/__init__.py
+rdf4j_python.egg-info/PKG-INFO
+rdf4j_python.egg-info/SOURCES.txt
+rdf4j_python.egg-info/dependency_links.txt
+rdf4j_python.egg-info/requires.txt
+rdf4j_python.egg-info/top_level.txt
+rdf4j_python/_client/__init__.py
+rdf4j_python/_client/_client.py
+rdf4j_python/_driver/__init__.py
+rdf4j_python/_driver/_async_rdf4j_db.py
+rdf4j_python/_driver/_async_repository.py
+rdf4j_python/exception/repo_exception.py
+rdf4j_python/model/_base_model.py
+rdf4j_python/model/repository.py
+rdf4j_python/utils/__init__.py
+rdf4j_python/utils/const.py
+tests/test_repository.py

rdf4j_python-0.1.0/rdf4j_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+httpx>=0.28.1
+rdflib>=7.1.4

rdf4j_python-0.1.0/rdf4j_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+rdf4j_python

rdf4j_python-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rdf4j_python-0.1.0/tests/test_repository.py

@@ -0,0 +1,75 @@
+import pytest
+
+from rdf4j_python import AsyncRdf4jDB
+from rdf4j_python.utils.const import Rdf4jContentType
+
+
+def get_repo_config(name: str):
+    return f"""
+        @prefix config: <tag:rdf4j.org,2023:config/>.
+
+        [] a config:Repository ;
+        config:rep.id "{name}" ;
+        rdfs:label "{name}" ;
+        config:rep.impl [
+            config:rep.type "openrdf:SailRepository" ;
+            config:sail.impl [
+                config:sail.type "openrdf:MemoryStore" ;
+            ]
+        ] .
+    """
+
+
+@pytest.mark.asyncio
+async def test_create_repo(rdf4j_service: str):
+    async with AsyncRdf4jDB(rdf4j_service) as db:
+        repo_id = "test_create_repo"
+        await db.create_repository(
+            repository_id=repo_id,
+            rdf_config_data=get_repo_config(repo_id),
+            content_type=Rdf4jContentType.TURTLE,
+        )
+        repos = await db.list_repositories()
+        assert len(repos) == 1
+        assert repos[0].id == repo_id
+        assert repos[0].title == repo_id
+        await db.delete_repository(repo_id)
+
+
+@pytest.mark.asyncio
+async def test_delete_repo(rdf4j_service: str):
+    async with AsyncRdf4jDB(rdf4j_service) as db:
+        repo_id = "test_delete_repo"
+        await db.create_repository(
+            repository_id=repo_id,
+            rdf_config_data=get_repo_config(repo_id),
+            content_type=Rdf4jContentType.TURTLE,
+        )
+        repos = await db.list_repositories()
+        assert len(repos) == 1
+        assert repos[0].id == repo_id
+        assert repos[0].title == repo_id
+        await db.delete_repository(repo_id)
+        repos = await db.list_repositories()
+        assert len(repos) == 0
+
+
+@pytest.mark.asyncio
+async def test_list_repos(rdf4j_service: str):
+    async with AsyncRdf4jDB(rdf4j_service) as db:
+        repo_count = 10
+        repos = await db.list_repositories()
+        assert len(repos) == 0
+        for repo in range(repo_count):
+            repo_id = f"test_list_repos_{repo}"
+            await db.create_repository(
+                repository_id=repo_id,
+                rdf_config_data=get_repo_config(repo_id),
+                content_type=Rdf4jContentType.TURTLE,
+            )
+        repos = await db.list_repositories()
+        assert len(repos) == repo_count
+        for repo in range(repo_count):
+            repo_id = f"test_list_repos_{repo}"
+            assert repo_id in [repo.id for repo in repos]
+            assert repo_id in [repo.title for repo in repos]