livepeer-frameworks 0.1.0__py3-none-any.whl

livepeer_frameworks/__init__.py

@@ -0,0 +1,81 @@
+"""Typed client for the FrameWorks GraphQL API."""
+
+from ._forward import OpenEnum, UnknownMember
+from ._generated.manifest import MIN_SERVER_VERSION, OPERATIONS, SDK_LINE, SDK_VERSION
+from ._server_info import ServerStatus
+from .client import AsyncFrameWorksClient, FrameWorksClient
+from .errors import (
+    AuthenticationError,
+    FrameWorksError,
+    GraphQLError,
+    HTTPError,
+    NetworkError,
+    PaymentRequiredError,
+    ProtocolError,
+    RateLimitError,
+    ResultError,
+    SchemaMismatchError,
+    ServerError,
+    ServerTooOldError,
+    UnsupportedOperationError,
+    UploadError,
+    WebhookVerificationError,
+)
+from .pagination import (
+    apaginate_offset,
+    apaginate_page_token,
+    apaginate_relay,
+    paginate_offset,
+    paginate_page_token,
+    paginate_relay,
+)
+from .playback_token import sign_playback_token
+from .results import expect_result
+from .retry import DEFAULT_RETRY_POLICY, RetryPolicy
+from .upload import async_upload_vod, upload_vod
+from .webhooks import WebhookEvent, WebhookReceiver, parse_webhook_event
+
+__version__ = SDK_VERSION
+
+__all__ = [
+    "AsyncFrameWorksClient",
+    "AuthenticationError",
+    "DEFAULT_RETRY_POLICY",
+    "FrameWorksClient",
+    "FrameWorksError",
+    "GraphQLError",
+    "HTTPError",
+    "MIN_SERVER_VERSION",
+    "NetworkError",
+    "OPERATIONS",
+    "OpenEnum",
+    "PaymentRequiredError",
+    "ProtocolError",
+    "RateLimitError",
+    "ResultError",
+    "RetryPolicy",
+    "SDK_LINE",
+    "SDK_VERSION",
+    "SchemaMismatchError",
+    "ServerError",
+    "ServerStatus",
+    "ServerTooOldError",
+    "UnknownMember",
+    "UnsupportedOperationError",
+    "UploadError",
+    "WebhookEvent",
+    "WebhookReceiver",
+    "WebhookVerificationError",
+    "__version__",
+    "apaginate_offset",
+    "apaginate_page_token",
+    "apaginate_relay",
+    "async_upload_vod",
+    "expect_result",
+    "paginate_offset",
+    "paginate_page_token",
+    "paginate_relay",
+    "parse_webhook_event",
+    "sign_playback_token",
+    "upload_vod",
+]

livepeer_frameworks/_forward.py

@@ -0,0 +1,97 @@
+"""Decoding of result union members and enum values a newer server adds.
+
+The SDK supports a range of server releases, and a later release may add a
+member to a union or a value to an enum. The generated models use the types
+below (codegen/forward_compat.py rewrites them), so such a response decodes
+instead of failing validation."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, get_args
+
+from pydantic import BaseModel, ConfigDict, GetCoreSchemaHandler, model_serializer
+from pydantic_core import core_schema
+
+# The tag the discriminator returns for a __typename no member declares. It
+# cannot collide with a GraphQL type name.
+_UNKNOWN_TAG = "<unknown>"
+
+
+class UnknownMember(BaseModel):
+    """A union member this SDK does not know: a type a newer server added.
+
+    typename__ is its __typename and raw its JSON exactly as the server sent
+    it; dumping the member returns raw. expect_result raises it as a
+    ResultError carrying its __typename, message, and code."""
+
+    model_config = ConfigDict(frozen=True)
+
+    typename__: str
+    raw: dict[str, Any]
+
+    @model_serializer
+    def _dump_raw(self) -> dict[str, Any]:
+        return self.raw
+
+
+class OpenUnion:
+    """Annotated metadata for a generated union field: members are chosen by
+    __typename, and a __typename no member declares becomes an UnknownMember.
+
+    The annotated type is Union[<generated members>, UnknownMember]; each
+    generated member declares its __typename as typename__: Literal[...]."""
+
+    def __get_pydantic_core_schema__(self, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
+        choices: dict[str, core_schema.CoreSchema] = {}
+        for member in get_args(source):
+            if member is UnknownMember:
+                continue
+            field = member.model_fields.get("typename__") if isinstance(member, type) and issubclass(member, BaseModel) else None
+            tags = get_args(field.annotation) if field is not None else ()
+            if not tags:
+                raise TypeError(f"union member {member!r} does not declare typename__ as a Literal")
+            for typename in tags:
+                choices[typename] = handler.generate_schema(member)
+        choices[_UNKNOWN_TAG] = core_schema.no_info_before_validator_function(
+            _unknown_member_input, handler.generate_schema(UnknownMember)
+        )
+        known = frozenset(choices) - {_UNKNOWN_TAG}
+
+        def tag(value: Any) -> str | None:
+            if isinstance(value, UnknownMember):
+                return _UNKNOWN_TAG
+            typename = value.get("__typename") if isinstance(value, dict) else getattr(value, "typename__", None)
+            if not isinstance(typename, str):
+                return None
+            return typename if typename in known else _UNKNOWN_TAG
+
+        return core_schema.tagged_union_schema(choices, tag)
+
+
+def _unknown_member_input(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {"typename__": value["__typename"], "raw": dict(value)}
+    return value
+
+
+class OpenEnum(str, Enum):
+    """Base of the generated enums. A value this SDK does not know, which a
+    newer server added, decodes to a member of the enum whose value and name
+    are the server's string and whose is_unknown is True; it is not one of
+    the enum's declared members, so an exhaustive match falls through to its
+    default case."""
+
+    @classmethod
+    def _missing_(cls, value: object) -> Any:
+        if not isinstance(value, str):
+            return None
+        member = str.__new__(cls, value)
+        member._name_ = value
+        member._value_ = value
+        return member
+
+    @property
+    def is_unknown(self) -> bool:
+        """Whether the value is one this SDK does not know."""
+        return self._value_ not in type(self)._value2member_map_

livepeer_frameworks/_generated/__init__.py

@@ -0,0 +1,3 @@
+"""Code generated by make graphql-sdk-py: the operation manifest, the event
+registry, the GraphQL clients and models (graphql/), and the public event
+payload types (proto/)."""

livepeer_frameworks/_generated/events.py

@@ -0,0 +1,67 @@
+# Code generated by scripts/sdkcontract from pkg/graphql/public and the event registry. DO NOT EDIT.
+
+from typing import Final
+
+import betterproto2
+
+from .proto.frameworks.events.public.v1 import (
+    AccountSuspended,
+    ApiTokenCreated,
+    ApiTokenRevoked,
+    BillingDetailsUpdated,
+    ClipFailed,
+    ClipReady,
+    ClipRequested,
+    CustomDomainFailed,
+    CustomDomainVerified,
+    InvoiceCreated,
+    InvoicePaid,
+    MultistreamStatusChanged,
+    PaymentFailed,
+    RecordingFailed,
+    RecordingReady,
+    StreamConnected,
+    StreamCreated,
+    StreamDeleted,
+    StreamIdle,
+    StreamKeyRotated,
+    StreamLive,
+    StreamUpdated,
+    TopupCredited,
+    UploadAborted,
+    UploadCompleted,
+    UploadCreated,
+    UploadFailed,
+    UploadReady,
+)
+
+PUBLIC_EVENT_MESSAGES: Final[dict[str, type[betterproto2.Message]]] = {
+    "account.suspended": AccountSuspended,
+    "api_token.created": ApiTokenCreated,
+    "api_token.revoked": ApiTokenRevoked,
+    "billing.details_updated": BillingDetailsUpdated,
+    "billing.invoice_created": InvoiceCreated,
+    "billing.invoice_paid": InvoicePaid,
+    "billing.payment_failed": PaymentFailed,
+    "billing.topup_credited": TopupCredited,
+    "clip.failed": ClipFailed,
+    "clip.ready": ClipReady,
+    "clip.requested": ClipRequested,
+    "custom_domain.failed": CustomDomainFailed,
+    "custom_domain.verified": CustomDomainVerified,
+    "multistream.status_changed": MultistreamStatusChanged,
+    "recording.failed": RecordingFailed,
+    "recording.ready": RecordingReady,
+    "stream.connected": StreamConnected,
+    "stream.created": StreamCreated,
+    "stream.deleted": StreamDeleted,
+    "stream.idle": StreamIdle,
+    "stream.key_rotated": StreamKeyRotated,
+    "stream.live": StreamLive,
+    "stream.updated": StreamUpdated,
+    "upload.aborted": UploadAborted,
+    "upload.completed": UploadCompleted,
+    "upload.created": UploadCreated,
+    "upload.failed": UploadFailed,
+    "upload.ready": UploadReady,
+}