reconify-python 0.1.0__py3-none-any.whl

reconify/pagination.py

@@ -0,0 +1,111 @@
+"""Synchronous and asynchronous helpers for Reconify page responses."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+
+def iter_cursor_pages(
+    fetch: Callable[..., Any],
+    *,
+    item_field: str,
+    query: dict[str, Any] | None = None,
+) -> Iterator[T]:
+    """Yield items while passing the server's opaque ``nextCursor`` onward."""
+
+    params = dict(query or {})
+    params.pop("offset", None) if params.get("after") is not None else None
+    while True:
+        page = fetch(params)
+        items = getattr(page, item_field, None) or []
+        yield from items
+        cursor = getattr(page, "next_cursor", None)
+        if not cursor:
+            return
+        params["after"] = cursor
+        if getattr(page, "limit", None) is not None and "limit" not in params:
+            params["limit"] = page.limit
+
+
+async def aiter_cursor_pages(
+    fetch: Callable[..., Awaitable[Any]],
+    *,
+    item_field: str,
+    query: dict[str, Any] | None = None,
+) -> AsyncIterator[T]:
+    """Async counterpart to :func:`iter_cursor_pages`."""
+
+    params = dict(query or {})
+    if params.get("after") is not None:
+        params.pop("offset", None)
+    while True:
+        page = await fetch(params)
+        items = getattr(page, item_field, None) or []
+        for item in items:
+            yield item
+        cursor = getattr(page, "next_cursor", None)
+        if not cursor:
+            return
+        params["after"] = cursor
+        if getattr(page, "limit", None) is not None and "limit" not in params:
+            params["limit"] = page.limit
+
+
+def iter_offset_pages(
+    fetch: Callable[..., Any],
+    *,
+    item_field: str,
+    query: dict[str, Any] | None = None,
+) -> Iterator[T]:
+    """Yield items using the server-reported offset and total."""
+
+    params = dict(query or {})
+    params.pop("after", None)
+    if params.get("offset") is None:
+        params["offset"] = 0
+    while True:
+        page = fetch(params)
+        items = list(getattr(page, item_field, None) or [])
+        yield from items
+        if not items:
+            return
+        offset = getattr(page, "offset", params["offset"])
+        total = getattr(page, "total", None)
+        next_offset = offset + len(items)
+        if total is not None and next_offset >= total:
+            return
+        params["offset"] = next_offset
+        if getattr(page, "limit", None) is not None and "limit" not in params:
+            params["limit"] = page.limit
+
+
+async def aiter_offset_pages(
+    fetch: Callable[..., Awaitable[Any]],
+    *,
+    item_field: str,
+    query: dict[str, Any] | None = None,
+) -> AsyncIterator[T]:
+    """Async counterpart to :func:`iter_offset_pages`."""
+
+    params = dict(query or {})
+    params.pop("after", None)
+    if params.get("offset") is None:
+        params["offset"] = 0
+    while True:
+        page = await fetch(params)
+        items = list(getattr(page, item_field, None) or [])
+        for item in items:
+            yield item
+        if not items:
+            return
+        offset = getattr(page, "offset", params["offset"])
+        total = getattr(page, "total", None)
+        next_offset = offset + len(items)
+        if total is not None and next_offset >= total:
+            return
+        params["offset"] = next_offset
+        if getattr(page, "limit", None) is not None and "limit" not in params:
+            params["limit"] = page.limit

reconify/resources/__init__.py

@@ -0,0 +1,124 @@
+"""Resource clients grouped by public API surface."""
+
+from .alerts import Alerts, AsyncAlerts
+from .events import AsyncEvents, Events
+from .ingestion import AsyncIngestion, Ingestion
+from .issues import AsyncIssues, Issues
+from .ledger import AsyncLedger, Ledger
+from .reconciliations import AsyncReconciliations, Reconciliations
+from .search import AsyncSearch, Search
+from .setup import AsyncSetup, Setup
+from .transactions import AsyncTransactions, Transactions
+from .wallets import AsyncWallets, Wallets
+
+SYNC_RESOURCE_CLASSES = {
+    "alerts": Alerts,
+    "events": Events,
+    "ingestion": Ingestion,
+    "issues": Issues,
+    "ledger": Ledger,
+    "reconciliations": Reconciliations,
+    "search": Search,
+    "setup": Setup,
+    "transactions": Transactions,
+    "wallets": Wallets,
+}
+ASYNC_RESOURCE_CLASSES = {
+    "alerts": AsyncAlerts,
+    "events": AsyncEvents,
+    "ingestion": AsyncIngestion,
+    "issues": AsyncIssues,
+    "ledger": AsyncLedger,
+    "reconciliations": AsyncReconciliations,
+    "search": AsyncSearch,
+    "setup": AsyncSetup,
+    "transactions": AsyncTransactions,
+    "wallets": AsyncWallets,
+}
+
+OPERATION_SPECS = {
+    "list_alert_rules": ("alerts", "GET", "/alerts/rules"),
+    "put_alert_rule": ("alerts", "PUT", "/alerts/rules"),
+    "list_events": ("events", "GET", "/events"),
+    "get_event": ("events", "GET", "/events/{id}"),
+    "reveal_event_field": ("events", "GET", "/events/{id}/reveal"),
+    "ingest_integrity_events": ("ingestion", "POST", "/integrity/events"),
+    "list_integrity_sources_for_reconciliation": ("reconciliations", "GET", "/integrity/sources"),
+    "ingest_integrity_test_events": ("ingestion", "POST", "/integrity/test-events"),
+    "list_issues": ("issues", "GET", "/issues"),
+    "get_issue_summary": ("issues", "GET", "/issues/summary"),
+    "get_issue": ("issues", "GET", "/issues/{id}"),
+    "update_issue": ("issues", "PATCH", "/issues/{id}"),
+    "list_issue_deliveries": ("issues", "GET", "/issues/{id}/deliveries"),
+    "retry_issue_delivery": ("issues", "POST", "/issues/{id}/deliveries/{deliveryId}/retry"),
+    "add_issue_note": ("issues", "POST", "/issues/{id}/notes"),
+    "resolve_issue": ("issues", "POST", "/issues/{id}/resolve"),
+    "list_ledger_sources": ("ledger", "GET", "/ledger/sources"),
+    "create_ledger_source": ("ledger", "POST", "/ledger/sources"),
+    "delete_ledger_source": ("ledger", "DELETE", "/ledger/sources/{id}"),
+    "get_ledger_source": ("ledger", "GET", "/ledger/sources/{id}"),
+    "update_ledger_source": ("ledger", "PATCH", "/ledger/sources/{id}"),
+    "list_source_periods": ("ledger", "GET", "/ledger/sources/{id}/periods"),
+    "list_transactions": ("ledger", "GET", "/ledger/sources/{id}/transactions"),
+    "ingest_transactions": ("ledger", "POST", "/ledger/sources/{id}/transactions"),
+    "list_reconciliation_schedules": ("reconciliations", "GET", "/reconciliation-schedules"),
+    "create_reconciliation_schedule": ("reconciliations", "POST", "/reconciliation-schedules"),
+    "delete_reconciliation_schedule": (
+        "reconciliations",
+        "DELETE",
+        "/reconciliation-schedules/{id}",
+    ),
+    "get_reconciliation_schedule": ("reconciliations", "GET", "/reconciliation-schedules/{id}"),
+    "update_reconciliation_schedule": (
+        "reconciliations",
+        "PATCH",
+        "/reconciliation-schedules/{id}",
+    ),
+    "list_reconciliations": ("reconciliations", "GET", "/reconciliations"),
+    "create_reconciliation": ("reconciliations", "POST", "/reconciliations"),
+    "get_reconciliation": ("reconciliations", "GET", "/reconciliations/{id}"),
+    "search_integrity_resources": ("search", "GET", "/search"),
+    "list_setup_integrations": ("setup", "GET", "/setup/integrations"),
+    "get_setup_integration": ("setup", "GET", "/setup/integrations/{id}"),
+    "list_setup_sources": ("setup", "GET", "/setup/sources"),
+    "create_setup_source": ("setup", "POST", "/setup/sources"),
+    "get_setup_source": ("setup", "GET", "/setup/sources/{id}"),
+    "update_setup_source": ("setup", "PATCH", "/setup/sources/{id}"),
+    "disable_setup_source": ("setup", "DELETE", "/setup/sources/{id}"),
+    "create_test_session": ("setup", "POST", "/setup/test-sessions"),
+    "get_test_session": ("setup", "GET", "/setup/test-sessions/{id}"),
+    "get_test_session_result": ("setup", "GET", "/setup/test-sessions/{id}/result"),
+    "retry_test_session": ("setup", "POST", "/setup/test-sessions/{id}/retry"),
+    "submit_test_session_events": ("setup", "POST", "/setup/test-sessions/{id}/submit"),
+    "list_wallet_transactions": ("transactions", "GET", "/transactions"),
+    "get_wallet_transaction": ("transactions", "GET", "/transactions/{id}"),
+    "list_wallets": ("wallets", "GET", "/wallets"),
+    "get_wallet": ("wallets", "GET", "/wallets/{id}"),
+    "get_wallet_balance": ("wallets", "GET", "/wallets/{id}/balance"),
+}
+
+__all__ = [
+    "Alerts",
+    "AsyncAlerts",
+    "AsyncEvents",
+    "AsyncIngestion",
+    "AsyncIssues",
+    "AsyncLedger",
+    "AsyncReconciliations",
+    "AsyncSearch",
+    "AsyncSetup",
+    "AsyncTransactions",
+    "AsyncWallets",
+    "Events",
+    "Ingestion",
+    "Issues",
+    "Ledger",
+    "Reconciliations",
+    "Search",
+    "Setup",
+    "Transactions",
+    "Wallets",
+    "ASYNC_RESOURCE_CLASSES",
+    "OPERATION_SPECS",
+    "SYNC_RESOURCE_CLASSES",
+]

reconify/resources/alerts.py

@@ -0,0 +1,58 @@
+"""Alerts API resource client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models import AlertRuleRequest, AlertRulesOutputBody, StatusOutputBody
+from .base import AsyncResource, SyncResource
+
+
+class Alerts(SyncResource):
+    def list_alert_rules(self, raw: bool = False, **query: Any) -> Any:
+        return self._request(
+            "GET",
+            "/alerts/rules",
+            params=query,
+            body=None,
+            response_model=AlertRulesOutputBody,
+            raw=raw,
+        )
+
+    def put_alert_rule(self, body: AlertRuleRequest, raw: bool = False, **query: Any) -> Any:
+        return self._request(
+            "PUT",
+            "/alerts/rules",
+            params=query,
+            body=body,
+            response_model=StatusOutputBody,
+            raw=raw,
+        )
+
+
+class AsyncAlerts(AsyncResource):
+    async def list_alert_rules(self, raw: bool = False, **query: Any) -> Any:
+        return await self._request(
+            "GET",
+            "/alerts/rules",
+            params=query,
+            body=None,
+            response_model=AlertRulesOutputBody,
+            raw=raw,
+        )
+
+    async def put_alert_rule(self, body: AlertRuleRequest, raw: bool = False, **query: Any) -> Any:
+        return await self._request(
+            "PUT",
+            "/alerts/rules",
+            params=query,
+            body=body,
+            response_model=StatusOutputBody,
+            raw=raw,
+        )
+
+
+OPERATION_SPECS = {
+    "list_alert_rules": ("alerts", "GET", "/alerts/rules"),
+    "put_alert_rule": ("alerts", "PUT", "/alerts/rules"),
+}

reconify/resources/base.py

@@ -0,0 +1,96 @@
+"""Shared implementation for resource clients."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+from urllib.parse import quote
+
+from ..errors import ReconifyValidationError
+from ..transport import AsyncTransport, SyncTransport
+
+_PATH_PARAMETER_RE = re.compile(r"\{([^}]+)\}")
+
+
+def _snake(value: str) -> str:
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", value).lower()
+
+
+class SyncResource:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any],
+        body: Any = None,
+        response_model: Any = None,
+        raw: bool = False,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        path_params = set(_PATH_PARAMETER_RE.findall(path))
+        wire_params = dict(params)
+        for name in path_params:
+            python_name = _snake(name)
+            if python_name not in wire_params or wire_params[python_name] is None:
+                raise ReconifyValidationError(f"Missing required path parameter: {python_name}")
+            path = path.replace("{" + name + "}", quote(str(wire_params.pop(python_name)), safe=""))
+        request_headers = dict(headers or {})
+        timeout = wire_params.pop("timeout", None)
+        if wire_params.get("integrity_test_session"):
+            request_headers["X-Integrity-Test-Session"] = wire_params.pop("integrity_test_session")
+        if wire_params.get("after") is not None:
+            wire_params.pop("offset", None)
+        return self._transport.request(
+            method,
+            path,
+            query=wire_params,
+            body=body,
+            headers=request_headers,
+            model=response_model,
+            raw=raw,
+            timeout=timeout,
+        )
+
+
+class AsyncResource:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any],
+        body: Any = None,
+        response_model: Any = None,
+        raw: bool = False,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        path_params = set(_PATH_PARAMETER_RE.findall(path))
+        wire_params = dict(params)
+        for name in path_params:
+            python_name = _snake(name)
+            if python_name not in wire_params or wire_params[python_name] is None:
+                raise ReconifyValidationError(f"Missing required path parameter: {python_name}")
+            path = path.replace("{" + name + "}", quote(str(wire_params.pop(python_name)), safe=""))
+        request_headers = dict(headers or {})
+        timeout = wire_params.pop("timeout", None)
+        if wire_params.get("integrity_test_session"):
+            request_headers["X-Integrity-Test-Session"] = wire_params.pop("integrity_test_session")
+        if wire_params.get("after") is not None:
+            wire_params.pop("offset", None)
+        return await self._transport.request(
+            method,
+            path,
+            query=wire_params,
+            body=body,
+            headers=request_headers,
+            model=response_model,
+            raw=raw,
+            timeout=timeout,
+        )

reconify/resources/events.py

@@ -0,0 +1,79 @@
+"""Events API resource client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models import EventDetail, EventPage, EventRevealOutputBody
+from .base import AsyncResource, SyncResource
+
+
+class Events(SyncResource):
+    def list_events(self, raw: bool = False, **query: Any) -> Any:
+        return self._request(
+            "GET",
+            "/events",
+            params=query,
+            body=None,
+            response_model=EventPage,
+            raw=raw,
+        )
+
+    def get_event(self, id: str, raw: bool = False, **query: Any) -> Any:
+        return self._request(
+            "GET",
+            "/events/{id}",
+            params={**query, "id": id},
+            body=None,
+            response_model=EventDetail,
+            raw=raw,
+        )
+
+    def reveal_event_field(self, id: str, raw: bool = False, **query: Any) -> Any:
+        return self._request(
+            "GET",
+            "/events/{id}/reveal",
+            params={**query, "id": id},
+            body=None,
+            response_model=EventRevealOutputBody,
+            raw=raw,
+        )
+
+
+class AsyncEvents(AsyncResource):
+    async def list_events(self, raw: bool = False, **query: Any) -> Any:
+        return await self._request(
+            "GET",
+            "/events",
+            params=query,
+            body=None,
+            response_model=EventPage,
+            raw=raw,
+        )
+
+    async def get_event(self, id: str, raw: bool = False, **query: Any) -> Any:
+        return await self._request(
+            "GET",
+            "/events/{id}",
+            params={**query, "id": id},
+            body=None,
+            response_model=EventDetail,
+            raw=raw,
+        )
+
+    async def reveal_event_field(self, id: str, raw: bool = False, **query: Any) -> Any:
+        return await self._request(
+            "GET",
+            "/events/{id}/reveal",
+            params={**query, "id": id},
+            body=None,
+            response_model=EventRevealOutputBody,
+            raw=raw,
+        )
+
+
+OPERATION_SPECS = {
+    "list_events": ("events", "GET", "/events"),
+    "get_event": ("events", "GET", "/events/{id}"),
+    "reveal_event_field": ("events", "GET", "/events/{id}/reveal"),
+}

reconify/resources/ingestion.py

@@ -0,0 +1,94 @@
+"""Ingestion API resource client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models import BatchResponse, IngestEventsInputBody
+from .base import AsyncResource, SyncResource
+
+
+class Ingestion(SyncResource):
+    def ingest_integrity_events(
+        self,
+        body: IngestEventsInputBody,
+        integrity_test_session: str | None = None,
+        raw: bool = False,
+        **query: Any,
+    ) -> Any:
+        return self._request(
+            "POST",
+            "/integrity/events",
+            params=query,
+            body=body,
+            response_model=BatchResponse,
+            raw=raw,
+            headers={"X-Integrity-Test-Session": integrity_test_session}
+            if integrity_test_session
+            else None,
+        )
+
+    def ingest_integrity_test_events(
+        self,
+        body: IngestEventsInputBody,
+        integrity_test_session: str | None = None,
+        raw: bool = False,
+        **query: Any,
+    ) -> Any:
+        return self._request(
+            "POST",
+            "/integrity/test-events",
+            params=query,
+            body=body,
+            response_model=BatchResponse,
+            raw=raw,
+            headers={"X-Integrity-Test-Session": integrity_test_session}
+            if integrity_test_session
+            else None,
+        )
+
+
+class AsyncIngestion(AsyncResource):
+    async def ingest_integrity_events(
+        self,
+        body: IngestEventsInputBody,
+        integrity_test_session: str | None = None,
+        raw: bool = False,
+        **query: Any,
+    ) -> Any:
+        return await self._request(
+            "POST",
+            "/integrity/events",
+            params=query,
+            body=body,
+            response_model=BatchResponse,
+            raw=raw,
+            headers={"X-Integrity-Test-Session": integrity_test_session}
+            if integrity_test_session
+            else None,
+        )
+
+    async def ingest_integrity_test_events(
+        self,
+        body: IngestEventsInputBody,
+        integrity_test_session: str | None = None,
+        raw: bool = False,
+        **query: Any,
+    ) -> Any:
+        return await self._request(
+            "POST",
+            "/integrity/test-events",
+            params=query,
+            body=body,
+            response_model=BatchResponse,
+            raw=raw,
+            headers={"X-Integrity-Test-Session": integrity_test_session}
+            if integrity_test_session
+            else None,
+        )
+
+
+OPERATION_SPECS = {
+    "ingest_integrity_events": ("ingestion", "POST", "/integrity/events"),
+    "ingest_integrity_test_events": ("ingestion", "POST", "/integrity/test-events"),
+}