capo-sagemaker-runtime-http2 0.1.0__py3-none-any.whl

capo_sagemaker_runtime_http2/errors/_base.py

@@ -0,0 +1,94 @@
+from typing import Literal
+
+
+class SageMakerRuntimeHTTP2Error(Exception):
+    """Base class for all SageMakerRuntimeHTTP2 service errors."""
+
+
+class ServiceError(SageMakerRuntimeHTTP2Error):
+    """Base class for all modeled service errors.
+
+    Args:
+        fault: ``"client"`` or ``"server"``.
+        is_throttling_error: Whether this error is a throttling error.
+        is_retryable: Whether this error is retryable.
+        code: The wire error code, or ``None``.
+        message: The error message, or ``None``.
+    """
+
+    code: str | None = None
+
+    def __init__(
+        self,
+        fault: Literal["client", "server"],
+        *,
+        is_throttling_error: bool,
+        is_retryable: bool,
+        code: str | None = None,
+        message: str | None = None,
+    ) -> None:
+        super().__init__(f"{code or '<no code>'}: {message or '<no message>'}")
+        self.fault = fault
+        self.is_throttling_error = is_throttling_error
+        self.is_retryable = is_retryable
+        self.code = code
+        self.message = message
+
+
+class SerializationError(SageMakerRuntimeHTTP2Error):
+    """Raised when a value cannot be serialized."""
+
+
+class DeserializationError(SageMakerRuntimeHTTP2Error):
+    """Raised when a value cannot be deserialized or a required member is missing."""
+
+
+class UnknownServiceError(ServiceError):
+    """Raised when the server returns an error code the client does not model.
+
+    Args:
+        code: ``<Code>`` text from the response body, or ``None`` if absent.
+        message: ``<Message>`` text from the response body, or ``None``.
+        response: The original HTTP response object, for arbitrary inspection.
+    """
+
+    def __init__(
+        self, *, code: str | None, message: str | None, response: object
+    ) -> None:
+        _status = getattr(response, "status", 500)
+        _fault: Literal["client", "server"] = "client" if _status < 500 else "server"
+        _throttling = _status == 429
+        _retryable = _throttling or _status >= 500
+        super().__init__(
+            _fault,
+            is_throttling_error=_throttling,
+            is_retryable=_retryable,
+            code=code,
+            message=message,
+        )
+        self.response = response
+
+
+class WaiterFailedError(SageMakerRuntimeHTTP2Error):
+    """Raised when a waiter hits an acceptor with ``state="failure"``.
+
+    Args:
+        waiter_name: snake_case waiter name (e.g. ``bucket_exists``).
+        reason: Short description of which acceptor fired.
+    """
+
+    def __init__(self, waiter_name: str, reason: str) -> None:
+        super().__init__(f"waiter {waiter_name} failed: {reason}")
+        self.waiter_name = waiter_name
+        self.reason = reason
+
+
+class WaiterTimeoutError(SageMakerRuntimeHTTP2Error):
+    """Raised when a waiter exhausts ``max_wait_time`` without a terminal acceptor."""
+
+    def __init__(self, waiter_name: str, max_wait_time: float) -> None:
+        super().__init__(
+            f"waiter {waiter_name} timed out after {max_wait_time} seconds"
+        )
+        self.waiter_name = waiter_name
+        self.max_wait_time = max_wait_time

capo_sagemaker_runtime_http2/errors/input_validation_error.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InputValidationError``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2.errors import ServiceError
+
+
+class InputValidationError_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>Error message.</p>"""
+    error_code: NotRequired["str"]
+    """<p>Error code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InputValidationError_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> InputValidationError_:
+    out: InputValidationError_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("ErrorCode") is not None:
+        out["error_code"] = data["ErrorCode"]
+    return out
+
+
+class InputValidationError(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InputValidationError``."""
+
+    code: str | None = "InputValidationError"
+
+    def __init__(self, data: InputValidationError_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InputValidationError",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InputValidationError":
+        return cls(deserialize_json(data), message)

capo_sagemaker_runtime_http2/errors/internal_server_error.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InternalServerError``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2.errors import ServiceError
+
+
+class InternalServerError_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>Error message.</p>"""
+    error_code: NotRequired["str"]
+    """<p>Error code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InternalServerError_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> InternalServerError_:
+    out: InternalServerError_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("ErrorCode") is not None:
+        out["error_code"] = data["ErrorCode"]
+    return out
+
+
+class InternalServerError(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InternalServerError``."""
+
+    code: str | None = "InternalServerError"
+
+    def __init__(self, data: InternalServerError_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InternalServerError",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "InternalServerError":
+        return cls(deserialize_json(data), message)

capo_sagemaker_runtime_http2/errors/internal_stream_failure.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InternalStreamFailure``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2._protocol.eventstream import HeaderValue, Message
+from capo_sagemaker_runtime_http2.errors import ServiceError
+
+
+class InternalStreamFailure_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>Error message.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InternalStreamFailure_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> InternalStreamFailure_:
+    out: InternalStreamFailure_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InternalStreamFailure(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InternalStreamFailure``."""
+
+    code: str | None = "InternalStreamFailure"
+
+    def __init__(self, data: InternalStreamFailure_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InternalStreamFailure",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InternalStreamFailure":
+        return cls(deserialize_json(data), message)
+
+
+def serialize_event_json(value: InternalStreamFailure_) -> bytes:
+    headers: dict[str, HeaderValue] = {":event-type": "InternalStreamFailure"}
+    payload = b""
+    return Message(headers=headers, payload=payload).encode()
+
+
+def deserialize_event_json(message: Message) -> InternalStreamFailure_:
+    headers = message.headers  # noqa: F841
+    payload = message.payload  # noqa: F841
+    out: InternalStreamFailure_ = {}  # type: ignore[typeddict-item]
+    return out

capo_sagemaker_runtime_http2/errors/model_error.py

@@ -0,0 +1,69 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#ModelError``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2.errors import ServiceError
+
+
+class ModelError_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>Error message.</p>"""
+    original_status_code: NotRequired["int"]
+    """<p>HTTP status code returned by model.</p>"""
+    original_message: NotRequired["str"]
+    """<p>Original error message from the model.</p>"""
+    log_stream_arn: NotRequired["str"]
+    """<p>CloudWatch log stream ARN.</p>"""
+    error_code: NotRequired["str"]
+    """<p>Error code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ModelError_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "original_status_code" in value:
+        out["OriginalStatusCode"] = value["original_status_code"]
+    if "original_message" in value:
+        out["OriginalMessage"] = value["original_message"]
+    if "log_stream_arn" in value:
+        out["LogStreamArn"] = value["log_stream_arn"]
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> ModelError_:
+    out: ModelError_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("OriginalStatusCode") is not None:
+        out["original_status_code"] = data["OriginalStatusCode"]
+    if data.get("OriginalMessage") is not None:
+        out["original_message"] = data["OriginalMessage"]
+    if data.get("LogStreamArn") is not None:
+        out["log_stream_arn"] = data["LogStreamArn"]
+    if data.get("ErrorCode") is not None:
+        out["error_code"] = data["ErrorCode"]
+    return out
+
+
+class ModelError(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.sagemakerruntimehttp2#ModelError``."""
+
+    code: str | None = "ModelError"
+
+    def __init__(self, data: ModelError_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ModelError",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ModelError":
+        return cls(deserialize_json(data), message)

capo_sagemaker_runtime_http2/errors/model_stream_error.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#ModelStreamError``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2._protocol.eventstream import HeaderValue, Message
+from capo_sagemaker_runtime_http2.errors import ServiceError
+
+
+class ModelStreamError_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>Error message.</p>"""
+    error_code: NotRequired["str"]
+    """<p>Error code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ModelStreamError_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> ModelStreamError_:
+    out: ModelStreamError_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("ErrorCode") is not None:
+        out["error_code"] = data["ErrorCode"]
+    return out
+
+
+class ModelStreamError(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.sagemakerruntimehttp2#ModelStreamError``."""
+
+    code: str | None = "ModelStreamError"
+
+    def __init__(self, data: ModelStreamError_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ModelStreamError",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ModelStreamError":
+        return cls(deserialize_json(data), message)
+
+
+def serialize_event_json(value: ModelStreamError_) -> bytes:
+    headers: dict[str, HeaderValue] = {":event-type": "ModelStreamError"}
+    payload = b""
+    return Message(headers=headers, payload=payload).encode()
+
+
+def deserialize_event_json(message: Message) -> ModelStreamError_:
+    headers = message.headers  # noqa: F841
+    payload = message.payload  # noqa: F841
+    out: ModelStreamError_ = {}  # type: ignore[typeddict-item]
+    return out

capo_sagemaker_runtime_http2/errors/service_unavailable_error.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#ServiceUnavailableError``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2.errors import ServiceError
+
+
+class ServiceUnavailableError_(TypedDict, closed=True):
+    message: NotRequired["str"]
+    """<p>Error message.</p>"""
+    error_code: NotRequired["str"]
+    """<p>Error code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceUnavailableError_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    return out
+
+
+def deserialize_json(data: dict) -> ServiceUnavailableError_:
+    out: ServiceUnavailableError_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    if data.get("ErrorCode") is not None:
+        out["error_code"] = data["ErrorCode"]
+    return out
+
+
+class ServiceUnavailableError(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.sagemakerruntimehttp2#ServiceUnavailableError``."""
+
+    code: str | None = "ServiceUnavailableError"
+
+    def __init__(self, data: ServiceUnavailableError_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ServiceUnavailableError",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ServiceUnavailableError":
+        return cls(deserialize_json(data), message)

capo_sagemaker_runtime_http2/types/_prelude/blob.py

@@ -0,0 +1,12 @@
+"""Generated from Smithy prelude shape ``smithy.api#Blob``."""
+
+import base64
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_json(data: str) -> bytes:
+    return base64.b64decode(data)

capo_sagemaker_runtime_http2/types/_prelude/timestamp.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: datetime.datetime) -> float:
+    value = (
+        value.astimezone(datetime.timezone.utc)
+        if value.tzinfo
+        else value.replace(tzinfo=datetime.timezone.utc)
+    )
+    return value.timestamp()
+
+
+def deserialize_json(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_sagemaker_runtime_http2/types/invoke_endpoint_with_bidirectional_stream_input.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InvokeEndpointWithBidirectionalStreamInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_sagemaker_runtime_http2.types.request_stream_event
+
+
+class InvokeEndpointWithBidirectionalStreamInput(TypedDict, closed=True):
+    endpoint_name: "str"
+    """<p>The name of the endpoint to invoke.</p>"""
+    body: "capo_sagemaker_runtime_http2.types.request_stream_event.RequestStreamEvent"
+    """<p>The request payload stream.</p>"""
+    target_variant: NotRequired["str"]
+    """<p>Target variant for the request.</p>"""
+    model_invocation_path: NotRequired["str"]
+    """<p>Model invocation path.</p>"""
+    model_query_string: NotRequired["str"]
+    """<p>Model query string.</p>"""

capo_sagemaker_runtime_http2/types/invoke_endpoint_with_bidirectional_stream_output.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#InvokeEndpointWithBidirectionalStreamOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_sagemaker_runtime_http2.types.response_stream_event
+
+
+class InvokeEndpointWithBidirectionalStreamOutput(TypedDict, closed=True):
+    body: "capo_sagemaker_runtime_http2.types.response_stream_event.ResponseStreamEvent"
+    """<p>The response payload stream.</p>"""
+    invoked_production_variant: NotRequired["str"]
+    """<p>The invoked production variant.</p>"""

capo_sagemaker_runtime_http2/types/request_payload_part.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#RequestPayloadPart``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_sagemaker_runtime_http2._protocol.eventstream import HeaderValue, Message
+
+if TYPE_CHECKING:
+    import capo_sagemaker_runtime_http2.types.sensitive_blob
+
+
+class RequestPayloadPart(TypedDict, closed=True):
+    bytes: NotRequired[
+        "capo_sagemaker_runtime_http2.types.sensitive_blob.SensitiveBlob"
+    ]
+    """<p>The payload bytes.</p>"""
+    data_type: NotRequired["str"]
+    r"""<p>Data type header. Can be one of these possible values: \"UTF8\", \"BINARY\".</p>"""
+    completion_state: NotRequired["str"]
+    r"""<p>Completion state header. Can be one of these possible values: \"PARTIAL\", \"COMPLETE\".</p>"""
+    p: NotRequired["str"]
+    """<p>Padding string for alignment.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RequestPayloadPart) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> RequestPayloadPart:
+    out: RequestPayloadPart = {}  # type: ignore[typeddict-item]
+    return out
+
+
+def serialize_event_json(value: RequestPayloadPart) -> bytes:
+    headers: dict[str, HeaderValue] = {":event-type": "PayloadPart"}
+    payload = b""
+    if "data_type" in value:
+        headers["DataType"] = value["data_type"]
+    if "completion_state" in value:
+        headers["CompletionState"] = value["completion_state"]
+    if "p" in value:
+        headers["P"] = value["p"]
+    payload = value["bytes"]
+    return Message(headers=headers, payload=payload).encode()
+
+
+def deserialize_event_json(message: Message) -> RequestPayloadPart:
+    headers = message.headers  # noqa: F841
+    payload = message.payload  # noqa: F841
+    out: RequestPayloadPart = {}  # type: ignore[typeddict-item]
+    if "DataType" in headers:
+        out["data_type"] = headers["DataType"]  # ty: ignore[invalid-assignment]
+    if "CompletionState" in headers:
+        out["completion_state"] = headers["CompletionState"]  # ty: ignore[invalid-assignment]
+    if "P" in headers:
+        out["p"] = headers["P"]  # ty: ignore[invalid-assignment]
+    if payload:
+        out["bytes"] = payload
+    return out

capo_sagemaker_runtime_http2/types/request_stream_event.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.sagemakerruntimehttp2#RequestStreamEvent``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_sagemaker_runtime_http2._iter import AnyIterator
+from capo_sagemaker_runtime_http2._protocol.eventstream import Message
+
+if TYPE_CHECKING:
+    import capo_sagemaker_runtime_http2.types.request_payload_part
+
+
+class _RequestStreamEvent_PayloadPart(TypedDict, closed=True):
+    PayloadPart: (
+        "capo_sagemaker_runtime_http2.types.request_payload_part.RequestPayloadPart"
+    )
+
+
+_RequestStreamEvent: TypeAlias = _RequestStreamEvent_PayloadPart
+RequestStreamEvent: TypeAlias = AnyIterator[_RequestStreamEvent]
+
+
+def serialize_event_json(value: _RequestStreamEvent) -> bytes:
+    match value:
+        case {"PayloadPart": payload}:
+            import capo_sagemaker_runtime_http2.types.request_payload_part
+
+            return capo_sagemaker_runtime_http2.types.request_payload_part.serialize_event_json(
+                payload
+            )
+        case _:
+            raise ValueError(f"RequestStreamEvent: unrecognized variant {value!r}")
+
+
+def deserialize_event_json(message: Message) -> _RequestStreamEvent:
+    headers = message.headers
+    message_type = headers.get(":message-type", "event")  # noqa: F841
+    event_type = headers.get(":event-type")
+    match event_type:
+        case "PayloadPart":
+            import capo_sagemaker_runtime_http2.types.request_payload_part
+
+            return {
+                "PayloadPart": capo_sagemaker_runtime_http2.types.request_payload_part.deserialize_event_json(
+                    message
+                )
+            }
+        case _:
+            raise ValueError(
+                f"RequestStreamEvent: unrecognized event-type {event_type!r}"
+            )