odatapy 5.0.0__py3-none-any.whl

odatapy/__init__.py

@@ -0,0 +1,30 @@
+"""odatapy — an OData v4.0 / v4.01 server and client library for Python.
+
+A port of Apache Olingo OData 5.0.0 (Java) to idiomatic Python.
+
+Quick start (server):
+
+    from odatapy.server import OData
+    from odatapy.server.inmemory import InMemoryDataStore, InMemoryProcessor
+
+    odata = OData.new_instance()
+    service_metadata = odata.create_service_metadata(MyProvider())
+    handler = odata.create_handler(service_metadata)
+    handler.register(InMemoryProcessor(store))
+    # wrap with odatapy.server.adapters.ODataASGIApp / ODataWSGIApp
+
+Quick start (client):
+
+    from odatapy.client import ODataClient
+    from odatapy.client.transport import HttpxTransport
+
+    client = ODataClient("http://host/svc", HttpxTransport())
+    products = client.get_entity_set(client.entity_set_uri("Products").filter("Price gt 10"))
+
+See docs/OLINGO_COMPARISON.md for what is implemented, what is deliberately not
+ported from Apache Olingo, and the known limitations.
+"""
+
+__version__ = "5.0.0"
+
+__all__ = ["__version__"]

odatapy/client/__init__.py

@@ -0,0 +1,132 @@
+"""OData client.
+
+Build request URIs with :class:`URIBuilder`, execute them through a pluggable
+:class:`~odatapy.client.transport.Transport` (httpx by default, or an in-process
+handler), and get back payload objects. :class:`ODataClient` is the entry point
+and :class:`AsyncODataClient` its asyncio twin; the EDM-enabled variants read
+``$metadata`` so payloads come back as canonical Python values.
+"""
+
+from odatapy.client.auth import (
+    Auth,
+    BasicAuth,
+    BearerAuth,
+    NoAuth,
+    OAuth2ClientCredentialsAuth,
+)
+from odatapy.client.batch import (
+    BatchItem,
+    BatchPartResponse,
+    BatchRequest,
+    BatchResponse,
+    ChangeSetBuilder,
+)
+from odatapy.client.client import (
+    AsyncEdmEnabledODataClient,
+    AsyncODataClient,
+    AsyncOperation,
+    AwaitableOperation,
+    EdmEnabledODataClient,
+    ODataClient,
+    RequestSpec,
+    build_prefer,
+)
+from odatapy.client.filters import (
+    Field,
+    Filter,
+    FilterArgFactory,
+    FilterFactory,
+    OrderBy,
+    Search,
+    SearchFactory,
+    and_,
+    it,
+    literal,
+    not_,
+    or_,
+    root,
+)
+from odatapy.client.responses import (
+    ClientResponse,
+    MediaResponse,
+    NotModified,
+    ODataClientError,
+    ODataInvokeResult,
+    ODataServerError,
+    ODataUpdateResult,
+    RawValue,
+    StreamedResponse,
+)
+from odatapy.client.serialization import ServiceDocument, ServiceDocumentEntry
+from odatapy.client.transport import (
+    AsyncHandlerTransport,
+    AsyncHttpxTransport,
+    AsyncPolicyTransport,
+    AsyncTransport,
+    HandlerTransport,
+    HttpxTransport,
+    PolicyTransport,
+    RetryPolicy,
+    Transport,
+)
+from odatapy.client.uri_builder import URIBuilder
+
+__all__ = [
+    # clients
+    "ODataClient",
+    "AsyncODataClient",
+    "EdmEnabledODataClient",
+    "AsyncEdmEnabledODataClient",
+    "AsyncOperation",
+    "AwaitableOperation",
+    "RequestSpec",
+    "build_prefer",
+    # URIs and expressions
+    "URIBuilder",
+    "Field",
+    "Filter",
+    "FilterFactory",
+    "FilterArgFactory",
+    "OrderBy",
+    "Search",
+    "SearchFactory",
+    "and_",
+    "or_",
+    "not_",
+    "it",
+    "root",
+    "literal",
+    # transports and auth
+    "Transport",
+    "AsyncTransport",
+    "HandlerTransport",
+    "AsyncHandlerTransport",
+    "HttpxTransport",
+    "AsyncHttpxTransport",
+    "PolicyTransport",
+    "AsyncPolicyTransport",
+    "RetryPolicy",
+    "Auth",
+    "NoAuth",
+    "BasicAuth",
+    "BearerAuth",
+    "OAuth2ClientCredentialsAuth",
+    # batch
+    "BatchRequest",
+    "BatchResponse",
+    "BatchItem",
+    "BatchPartResponse",
+    "ChangeSetBuilder",
+    # responses
+    "ClientResponse",
+    "MediaResponse",
+    "NotModified",
+    "RawValue",
+    "StreamedResponse",
+    "ODataInvokeResult",
+    "ODataUpdateResult",
+    "ODataClientError",
+    "ODataServerError",
+    "ServiceDocument",
+    "ServiceDocumentEntry",
+]

odatapy/client/auth.py

@@ -0,0 +1,159 @@
+"""Authentication helpers for the client transports.
+
+An :class:`Auth` adds credentials to outgoing request headers and may react to a
+``401 Unauthorized`` by refreshing them (the transport then retries once)::
+
+    transport = HttpxTransport(auth=BasicAuth("alice", "secret"))
+    transport = HttpxTransport(auth=BearerAuth("eyJ..."))
+    transport = HttpxTransport(
+        auth=OAuth2ClientCredentialsAuth("https://idp/token", "client-id", "client-secret")
+    )
+"""
+
+from __future__ import annotations
+
+import base64
+import time
+from typing import Any, Callable, Protocol
+
+from odatapy.client.responses import ClientResponse
+
+
+class Auth(Protocol):
+    def apply(self, headers: dict[str, str]) -> None:
+        """Add credentials to the request headers (in place)."""
+
+    def on_unauthorized(self, response: ClientResponse) -> bool:
+        """Called on a 401; return True to refresh credentials and retry once."""
+
+
+class NoAuth:
+    def apply(self, headers: dict[str, str]) -> None:
+        return None
+
+    def on_unauthorized(self, response: ClientResponse) -> bool:
+        return False
+
+
+class BasicAuth:
+    """HTTP Basic authentication."""
+
+    def __init__(self, username: str, password: str) -> None:
+        token = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii")
+        self._header = f"Basic {token}"
+
+    def apply(self, headers: dict[str, str]) -> None:
+        headers["Authorization"] = self._header
+
+    def on_unauthorized(self, response: ClientResponse) -> bool:
+        return False
+
+
+class BearerAuth:
+    """``Authorization: Bearer <token>``; ``token`` may be a string or a callable
+    returning the current token (called on every request and after a 401)."""
+
+    def __init__(self, token: str | Callable[[], str]) -> None:
+        self._token = token
+
+    @property
+    def token(self) -> str:
+        return self._token() if callable(self._token) else self._token
+
+    def apply(self, headers: dict[str, str]) -> None:
+        headers["Authorization"] = f"Bearer {self.token}"
+
+    def on_unauthorized(self, response: ClientResponse) -> bool:
+        # A callable token source can produce a fresh token; a static one cannot.
+        return callable(self._token)
+
+
+class OAuth2ClientCredentialsAuth:
+    """OAuth 2.0 client-credentials grant.
+
+    Fetches an access token from ``token_url`` (form-encoded POST) on first use,
+    refreshes it when ``expires_in`` has elapsed, and once more after a 401.
+    ``token_fetcher`` can replace the HTTP call (it must return the token
+    response dict) - handy for tests or non-standard identity providers.
+    """
+
+    def __init__(
+        self,
+        token_url: str,
+        client_id: str,
+        client_secret: str,
+        scope: str | None = None,
+        *,
+        token_fetcher: Callable[[], dict[str, Any]] | None = None,
+        extra_params: dict[str, str] | None = None,
+        leeway: float = 30.0,
+        httpx_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        self.token_url = token_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scope = scope
+        self.extra_params = dict(extra_params or {})
+        self.leeway = leeway
+        self._fetcher = token_fetcher
+        self._httpx_kwargs = httpx_kwargs or {}
+        self._access_token: str | None = None
+        self._expires_at: float | None = None
+        self._token_type = "Bearer"
+
+    # --- token management ------------------------------------------------
+    @property
+    def access_token(self) -> str | None:
+        return self._access_token
+
+    def is_expired(self) -> bool:
+        if self._access_token is None:
+            return True
+        if self._expires_at is None:
+            return False
+        return time.monotonic() >= self._expires_at - self.leeway
+
+    def fetch_token(self) -> str:
+        data = self._fetcher() if self._fetcher is not None else self._request_token()
+        token = data.get("access_token")
+        if not token:
+            raise ValueError("The token endpoint did not return an access_token.")
+        self._access_token = str(token)
+        self._token_type = str(data.get("token_type") or "Bearer")
+        expires_in = data.get("expires_in")
+        self._expires_at = (
+            time.monotonic() + float(expires_in) if expires_in is not None else None
+        )
+        return self._access_token
+
+    def _request_token(self) -> dict[str, Any]:
+        import httpx
+
+        form = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            **self.extra_params,
+        }
+        if self.scope:
+            form["scope"] = self.scope
+        response = httpx.post(self.token_url, data=form, **self._httpx_kwargs)
+        response.raise_for_status()
+        return response.json()
+
+    def invalidate(self) -> None:
+        self._access_token = None
+        self._expires_at = None
+
+    # --- Auth protocol ---------------------------------------------------
+    def apply(self, headers: dict[str, str]) -> None:
+        if self.is_expired():
+            self.fetch_token()
+        headers["Authorization"] = f"{self._token_type} {self._access_token}"
+
+    def on_unauthorized(self, response: ClientResponse) -> bool:
+        self.invalidate()
+        return True
+
+
+__all__ = ["Auth", "BasicAuth", "BearerAuth", "NoAuth", "OAuth2ClientCredentialsAuth"]