redblack-python-sdk 0.1.0__py3-none-any.whl

redblack/__init__.py

@@ -0,0 +1,105 @@
+"""Typed synchronous SDK for the RedBlack API."""
+
+from ._version import SUPPORTED_API_VERSION, __version__
+from .auth import (
+    PasswordCredentials,
+    PasswordGrantTokenProvider,
+    StaticTokenProvider,
+    TokenProvider,
+)
+from .client import HttpInfoClient, RedBlackClient
+from .config import Environment, RedBlackConfig, RetryConfig, TimeoutConfig
+from .downloads import (
+    DownloadError,
+    DownloadExistsError,
+    DownloadResult,
+    DownloadSecurityError,
+    StorageUrlPolicy,
+)
+from .errors import (
+    ApiError,
+    AuthenticationError,
+    BadRequestError,
+    ConfigurationError,
+    ConflictError,
+    ForbiddenError,
+    GoneError,
+    MethodNotAllowedError,
+    NotFoundError,
+    OperationFailedError,
+    OperationNeedsInputError,
+    PollingError,
+    PollTimeoutError,
+    PreconditionFailedError,
+    RateLimitError,
+    RedBlackError,
+    RequestTimeoutError,
+    ResponseDecodeError,
+    ServerError,
+    TransportError,
+    UnauthorizedError,
+    UnprocessableContentError,
+)
+from .odata import ODataQuery
+from .pagination import Page
+from .resources import (
+    CONFIRM_DELETE_ALL_CASH_ACTIONS,
+    ExportJobHandle,
+    OrderAddSessionHandle,
+    ReleaseCriteria,
+    ReleaseSessionHandle,
+    VersionedResource,
+)
+from .response import ApiResponse, HttpMetadata
+
+__all__ = [
+    "ApiError",
+    "ApiResponse",
+    "AuthenticationError",
+    "BadRequestError",
+    "CONFIRM_DELETE_ALL_CASH_ACTIONS",
+    "ConfigurationError",
+    "ConflictError",
+    "DownloadError",
+    "DownloadExistsError",
+    "DownloadResult",
+    "DownloadSecurityError",
+    "Environment",
+    "ExportJobHandle",
+    "ForbiddenError",
+    "GoneError",
+    "HttpInfoClient",
+    "HttpMetadata",
+    "MethodNotAllowedError",
+    "NotFoundError",
+    "ODataQuery",
+    "OperationFailedError",
+    "OperationNeedsInputError",
+    "OrderAddSessionHandle",
+    "Page",
+    "PasswordCredentials",
+    "PasswordGrantTokenProvider",
+    "PollingError",
+    "PollTimeoutError",
+    "PreconditionFailedError",
+    "RateLimitError",
+    "RedBlackClient",
+    "RedBlackConfig",
+    "RedBlackError",
+    "ReleaseCriteria",
+    "ReleaseSessionHandle",
+    "RequestTimeoutError",
+    "ResponseDecodeError",
+    "RetryConfig",
+    "SUPPORTED_API_VERSION",
+    "ServerError",
+    "StaticTokenProvider",
+    "StorageUrlPolicy",
+    "TimeoutConfig",
+    "TokenProvider",
+    "TransportError",
+    "UnauthorizedError",
+    "UnprocessableContentError",
+    "VersionedResource",
+    "__version__",
+]

redblack/_generated/__init__.py

@@ -0,0 +1,39 @@
+"""Generated RedBlack 2026.3.0 contract registry."""
+
+from .contract import (
+    OPERATIONS,
+    REQUEST_MODELS,
+    RESPONSE_MODELS,
+    ContractLookupError,
+    encode_request,
+    get_operation_spec,
+    parse_response,
+    validate_request,
+)
+from .operation_specs import (
+    API_RELEASE,
+    OPERATION_IDS,
+    MediaTypeSpec,
+    OperationSpec,
+    ParameterSpec,
+    RequestBodySpec,
+    ResponseSpec,
+)
+
+__all__ = [
+    "API_RELEASE",
+    "ContractLookupError",
+    "MediaTypeSpec",
+    "OPERATION_IDS",
+    "OPERATIONS",
+    "OperationSpec",
+    "ParameterSpec",
+    "REQUEST_MODELS",
+    "RESPONSE_MODELS",
+    "RequestBodySpec",
+    "ResponseSpec",
+    "encode_request",
+    "get_operation_spec",
+    "parse_response",
+    "validate_request",
+]

redblack/_generated/contract.py

@@ -0,0 +1,212 @@
+# This file is generated by tools/generate_sdk_models.py.
+# Do not edit it by hand.
+"""Stable runtime helpers over generated RedBlack operation metadata."""
+
+from __future__ import annotations
+
+import json
+import math
+from datetime import date, datetime
+from decimal import Decimal
+from enum import Enum
+
+from pydantic import BaseModel
+
+from .operation_specs import (
+    OPERATIONS,
+    MediaTypeSpec,
+    OperationSpec,
+)
+
+
+class ContractLookupError(ValueError):
+    """Raised when a call cannot be represented by the captured contract."""
+
+
+def get_operation_spec(operation_id: str) -> OperationSpec:
+    """Return exact metadata for one captured operation."""
+
+    try:
+        return OPERATIONS[operation_id]
+    except KeyError as error:
+        raise ContractLookupError(f"unknown RedBlack operation: {operation_id}") from error
+
+
+def _normalize_media_type(value: str | None) -> str | None:
+    if value is None:
+        return None
+    return value.partition(";")[0].strip().lower() or None
+
+
+def _select_media(
+    media_types: tuple[MediaTypeSpec, ...],
+    requested: str | None,
+) -> MediaTypeSpec | None:
+    if not media_types:
+        return None
+    normalized = _normalize_media_type(requested)
+    if normalized is not None:
+        for media in media_types:
+            if media.media_type.lower() == normalized:
+                return media
+        if normalized.endswith("+json") or normalized == "application/json":
+            json_media = [
+                media
+                for media in media_types
+                if media.media_type.lower().endswith("+json")
+                or media.media_type.lower() == "application/json"
+            ]
+            if len(json_media) == 1:
+                return json_media[0]
+        raise ContractLookupError(
+            f"content type {requested!r} is not documented; "
+            f"expected {[item.media_type for item in media_types]!r}"
+        )
+    if len(media_types) == 1:
+        return media_types[0]
+    raise ContractLookupError(
+        "content type is required when an operation documents multiple representations"
+    )
+
+
+def validate_request(
+    operation_id: str,
+    value: object,
+    *,
+    media_type: str = "application/json",
+) -> object | None:
+    """Validate and alias an outbound body while retaining exact ``Decimal`` values."""
+
+    operation = get_operation_spec(operation_id)
+    body = operation.request_body
+    if body is None:
+        if value is not None:
+            raise ContractLookupError(f"{operation_id} does not document a request body")
+        return None
+    if value is None:
+        if body.required:
+            raise ContractLookupError(f"{operation_id} requires a request body")
+        return None
+    selected = _select_media(body.media_types, media_type)
+    if selected is None:
+        raise ContractLookupError(f"{operation_id} has no typed request representation")
+    validated = selected.adapter.validate_python(value)
+    return selected.adapter.dump_python(
+        validated,
+        mode="python",
+        by_alias=True,
+        exclude_unset=True,
+    )
+
+
+def _encode_json_value(value: object) -> str:
+    if value is None:
+        return "null"
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, Enum):
+        return _encode_json_value(value.value)
+    if isinstance(value, Decimal):
+        if not value.is_finite():
+            raise ValueError("non-finite Decimal values are not valid JSON")
+        return str(value)
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ValueError("non-finite float values are not valid JSON")
+        return json.dumps(value, ensure_ascii=False, allow_nan=False)
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, datetime):
+        if value.tzinfo is None or value.utcoffset() is None:
+            raise ValueError("request datetimes must include an explicit UTC offset")
+        return json.dumps(value.isoformat(), ensure_ascii=False)
+    if isinstance(value, date):
+        return json.dumps(value.isoformat(), ensure_ascii=False)
+    if isinstance(value, BaseModel):
+        value = value.model_dump(mode="python", by_alias=True, exclude_unset=True)
+    if isinstance(value, dict):
+        pieces = []
+        for key, child in value.items():
+            if not isinstance(key, str):
+                raise TypeError("JSON object keys must be strings")
+            pieces.append(json.dumps(key, ensure_ascii=False) + ":" + _encode_json_value(child))
+        return "{" + ",".join(pieces) + "}"
+    if isinstance(value, list | tuple):
+        return "[" + ",".join(_encode_json_value(child) for child in value) + "]"
+    raise TypeError(f"value of type {type(value).__name__} is not JSON serializable")
+
+
+def encode_request(
+    operation_id: str,
+    value: object,
+    *,
+    media_type: str = "application/json",
+) -> bytes | None:
+    """Validate and encode a body without routing decimal tokens through ``float``."""
+
+    validated = validate_request(operation_id, value, media_type=media_type)
+    if validated is None:
+        return None
+    return _encode_json_value(validated).encode("utf-8")
+
+
+def parse_response(
+    operation_id: str,
+    status_code: int,
+    raw_bytes: bytes,
+    content_type: str | None,
+) -> object | None:
+    """Parse directly from response bytes using the documented status schema."""
+
+    operation = get_operation_spec(operation_id)
+    response = operation.response(status_code)
+    if response is None:
+        raise ContractLookupError(f"{operation_id} does not document response status {status_code}")
+    selected = _select_media(response.media_types, content_type)
+    if selected is None:
+        return None
+    if not raw_bytes.strip():
+        raise ContractLookupError(
+            f"{operation_id} response {status_code} documents "
+            f"{selected.media_type} but returned an empty body"
+        )
+
+    # The minimum supported Pydantic 2 releases route JSON numeric tokens
+    # through binary float before Decimal validation.  Decode with the standard
+    # library's exact parse hook first so vendor-decimal digits are retained.
+    def reject_non_finite(value: str) -> object:
+        raise ValueError(f"non-finite JSON number is not supported: {value}")
+
+    decoded = json.loads(
+        raw_bytes,
+        parse_float=Decimal,
+        parse_constant=reject_non_finite,
+    )
+    return selected.adapter.validate_python(decoded)
+
+
+REQUEST_MODELS: dict[str, object | None] = {
+    operation_id: operation.request_model for operation_id, operation in OPERATIONS.items()
+}
+RESPONSE_MODELS: dict[tuple[str, int, str], object] = {
+    (operation_id, response.status_code, media.media_type): media.model
+    for operation_id, operation in OPERATIONS.items()
+    for response in operation.responses
+    for media in response.media_types
+}
+
+
+__all__ = [
+    "ContractLookupError",
+    "OPERATIONS",
+    "REQUEST_MODELS",
+    "RESPONSE_MODELS",
+    "encode_request",
+    "get_operation_spec",
+    "parse_response",
+    "validate_request",
+]