capo-lambda-web 0.2.0__py3-none-any.whl

capo_lambda_web/types/s3_object.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#S3Object``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+
+class S3Object(TypedDict, closed=True):
+    bucket: "str"
+    """<p>The name of the Amazon S3 bucket. Must be between 3 and 63 characters.</p>"""
+    key: "str"
+    """<p>The Amazon S3 object key. Must be between 1 and 1024 characters.</p>"""
+    version_id: NotRequired["str"]
+    """<p>The version ID of the Amazon S3 object.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: S3Object) -> dict:
+    out: dict = {}
+    out["bucket"] = value["bucket"]
+    out["key"] = value["key"]
+    if "version_id" in value:
+        out["versionId"] = value["version_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> S3Object:
+    out: S3Object = {}  # type: ignore[typeddict-item]
+    if data.get("bucket") is not None:
+        out["bucket"] = data["bucket"]
+    else:
+        raise DeserializationError("S3Object.bucket required")
+    if data.get("key") is not None:
+        out["key"] = data["key"]
+    else:
+        raise DeserializationError("S3Object.key required")
+    if data.get("versionId") is not None:
+        out["version_id"] = data["versionId"]
+    return out

capo_lambda_web/types/scaling_config.py

@@ -0,0 +1,23 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ScalingConfig``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class ScalingConfig(TypedDict, closed=True):
+    max_environments: NotRequired["int"]
+    """<p>The maximum number of concurrent execution environments for the endpoint. Minimum value of 2, maximum value of 10000. There is no default value. If you don't specify a value, the scaling configuration is absent from the response. On an update, omit <code>scalingConfig</code> to keep the current value, or specify an empty object to clear a previously set value.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ScalingConfig) -> dict:
+    out: dict = {}
+    if "max_environments" in value:
+        out["maxEnvironments"] = value["max_environments"]
+    return out
+
+
+def deserialize_json(data: dict) -> ScalingConfig:
+    out: ScalingConfig = {}  # type: ignore[typeddict-item]
+    if data.get("maxEnvironments") is not None:
+        out["max_environments"] = data["maxEnvironments"]
+    return out

capo_lambda_web/types/service_config.py

@@ -0,0 +1,87 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ServiceConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.environment_variables
+    import capo_lambda_web.types.role_arn
+    import capo_lambda_web.types.telemetry_config
+
+
+class ServiceConfig(TypedDict, closed=True):
+    execution_role_arn: "capo_lambda_web.types.role_arn.RoleArn"
+    """<p>The ARN of the IAM role that the web function assumes when it runs. This role provides permissions to access AWS services and resources.</p>"""
+    timeout_seconds: "int"
+    """<p>The amount of time (in seconds) that Lambda allows the web function to run before stopping it. Minimum value of 3, maximum value of 900. If you don't specify a value, the default is 30, and this default is returned in the response.</p>"""
+    max_concurrency_per_environment: "int"
+    """<p>The maximum number of concurrent requests handled per execution environment. Minimum value of 1, maximum value of 128. If you don't specify a value, the default is 64, and this default is returned in the response.</p>"""
+    environment_variables: NotRequired[
+        "capo_lambda_web.types.environment_variables.EnvironmentVariables"
+    ]
+    """<p>A map of environment variable key-value pairs available to the web function at runtime. Environment variable values are sensitive.</p>"""
+    telemetry_config: NotRequired[
+        "capo_lambda_web.types.telemetry_config.TelemetryConfig"
+    ]
+    """<p>The telemetry configuration for the web function, including logging settings.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceConfig) -> dict:
+    out: dict = {}
+    out["executionRoleArn"] = value["execution_role_arn"]
+    out["timeoutSeconds"] = value.get("timeout_seconds", 30)
+    out["maxConcurrencyPerEnvironment"] = value.get(
+        "max_concurrency_per_environment", 64
+    )
+    if "environment_variables" in value:
+        import capo_lambda_web.types.environment_variables
+
+        out["environmentVariables"] = (
+            capo_lambda_web.types.environment_variables.serialize_json(
+                value["environment_variables"]
+            )
+        )
+    if "telemetry_config" in value:
+        import capo_lambda_web.types.telemetry_config
+
+        out["telemetryConfig"] = capo_lambda_web.types.telemetry_config.serialize_json(
+            value["telemetry_config"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ServiceConfig:
+    out: ServiceConfig = {}  # type: ignore[typeddict-item]
+    if data.get("executionRoleArn") is not None:
+        out["execution_role_arn"] = data["executionRoleArn"]
+    else:
+        raise DeserializationError("ServiceConfig.execution_role_arn required")
+    if data.get("timeoutSeconds") is not None:
+        out["timeout_seconds"] = data["timeoutSeconds"]
+    else:
+        out["timeout_seconds"] = 30
+    if data.get("maxConcurrencyPerEnvironment") is not None:
+        out["max_concurrency_per_environment"] = data["maxConcurrencyPerEnvironment"]
+    else:
+        out["max_concurrency_per_environment"] = 64
+    if data.get("environmentVariables") is not None:
+        import capo_lambda_web.types.environment_variables
+
+        out["environment_variables"] = (
+            capo_lambda_web.types.environment_variables.deserialize_json(
+                data["environmentVariables"]
+            )
+        )
+    if data.get("telemetryConfig") is not None:
+        import capo_lambda_web.types.telemetry_config
+
+        out["telemetry_config"] = (
+            capo_lambda_web.types.telemetry_config.deserialize_json(
+                data["telemetryConfig"]
+            )
+        )
+    return out

capo_lambda_web/types/system_log_level.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#SystemLogLevel``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>The log level for system logs from the Lambda runtime. Possible values: <code>DEBUG</code>, <code>INFO</code>, <code>WARN</code>.</p>"""
+SystemLogLevel: TypeAlias = Literal[
+    "DEBUG",
+    "INFO",
+    "WARN",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SystemLogLevel) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> SystemLogLevel:
+    return cast(SystemLogLevel, data)

capo_lambda_web/types/tag_key.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#TagKey``."""
+
+from typing import TypeAlias
+
+TagKey: TypeAlias = str

capo_lambda_web/types/tag_key_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#TagKeyList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.tag_key
+
+TagKeyList: TypeAlias = list["capo_lambda_web.types.tag_key.TagKey"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagKeyList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> TagKeyList:
+    return [item for item in data if item is not None]

capo_lambda_web/types/tag_resource_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.resource_arn
+    import capo_lambda_web.types.tags
+
+
+class TagResourceRequest(TypedDict, closed=True):
+    resource: "capo_lambda_web.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the web function.</p>"""
+    tags: "capo_lambda_web.types.tags.Tags"
+    """<p>A map of tag keys and values to add to the web function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagResourceRequest) -> dict:
+    out: dict = {}
+    import capo_lambda_web.types.tags
+
+    out["Tags"] = capo_lambda_web.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> TagResourceRequest:
+    out: TagResourceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("Tags") is not None:
+        import capo_lambda_web.types.tags
+
+        out["tags"] = capo_lambda_web.types.tags.deserialize_json(data["Tags"])
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

capo_lambda_web/types/tags.py

@@ -0,0 +1,25 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#Tags``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.tag_key
+
+Tags: TypeAlias = dict["capo_lambda_web.types.tag_key.TagKey", "str"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: Tags) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_json(data: dict) -> Tags:
+    out: Tags = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        out[key] = value
+    return out

capo_lambda_web/types/telemetry_config.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#TelemetryConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.logging_config
+
+
+class TelemetryConfig(TypedDict, closed=True):
+    logging_config: NotRequired["capo_lambda_web.types.logging_config.LoggingConfig"]
+    """<p>The logging configuration for the web function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TelemetryConfig) -> dict:
+    out: dict = {}
+    if "logging_config" in value:
+        import capo_lambda_web.types.logging_config
+
+        out["loggingConfig"] = capo_lambda_web.types.logging_config.serialize_json(
+            value["logging_config"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> TelemetryConfig:
+    out: TelemetryConfig = {}  # type: ignore[typeddict-item]
+    if data.get("loggingConfig") is not None:
+        import capo_lambda_web.types.logging_config
+
+        out["logging_config"] = capo_lambda_web.types.logging_config.deserialize_json(
+            data["loggingConfig"]
+        )
+    return out

capo_lambda_web/types/throttle_config.py

@@ -0,0 +1,23 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ThrottleConfig``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class ThrottleConfig(TypedDict, closed=True):
+    rate_limit: NotRequired["int"]
+    """<p>The maximum request rate per second for the endpoint. The value must be one of the following supported values: <code>0</code>, <code>100</code>, <code>200</code>, <code>300</code>, <code>400</code>, <code>500</code>, <code>600</code>, <code>700</code>, <code>800</code>, <code>900</code>, <code>1000</code>, <code>2000</code>, <code>3000</code>, <code>4000</code>, <code>5000</code>, <code>6000</code>, <code>7000</code>, <code>8000</code>, <code>9000</code>, or <code>10000</code>. The maximum effective value is also bounded by your account-level maximum total rate limit. There is no default value. If you don't specify a value, the throttling configuration is absent from the response. On an update, omit <code>throttleConfig</code> to keep the current value, or specify an empty object to clear a previously set value.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ThrottleConfig) -> dict:
+    out: dict = {}
+    if "rate_limit" in value:
+        out["rateLimit"] = value["rate_limit"]
+    return out
+
+
+def deserialize_json(data: dict) -> ThrottleConfig:
+    out: ThrottleConfig = {}  # type: ignore[typeddict-item]
+    if data.get("rateLimit") is not None:
+        out["rate_limit"] = data["rateLimit"]
+    return out

capo_lambda_web/types/untag_resource_request.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#UntagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.resource_arn
+    import capo_lambda_web.types.tag_key_list
+
+
+class UntagResourceRequest(TypedDict, closed=True):
+    resource: "capo_lambda_web.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the web function.</p>"""
+    tag_keys: "capo_lambda_web.types.tag_key_list.TagKeyList"
+    """<p>A list of tag keys to remove from the web function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UntagResourceRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> UntagResourceRequest:
+    out: UntagResourceRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda_web/types/update_web_function_endpoint_request.py

@@ -0,0 +1,121 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#UpdateWebFunctionEndpointRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.auth_type
+    import capo_lambda_web.types.auto_deployment_mode
+    import capo_lambda_web.types.description
+    import capo_lambda_web.types.endpoint_name
+    import capo_lambda_web.types.function_name
+    import capo_lambda_web.types.revision_weight_list
+    import capo_lambda_web.types.scaling_config
+    import capo_lambda_web.types.throttle_config
+
+
+class UpdateWebFunctionEndpointRequest(TypedDict, closed=True):
+    function_name: "capo_lambda_web.types.function_name.FunctionName"
+    """<p>The name of the web function. You can specify the function name or the function ARN. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    endpoint_name: "capo_lambda_web.types.endpoint_name.EndpointName"
+    """<p>The name of the endpoint to update. You can specify the endpoint name or the endpoint ARN. The length constraint applies only to the full ARN. If you specify only the endpoint name, it is limited to 64 characters in length.</p>"""
+    description: NotRequired["capo_lambda_web.types.description.Description"]
+    """<p>A description of the endpoint.</p>"""
+    auth_type: NotRequired["capo_lambda_web.types.auth_type.AuthType"]
+    """<p>The authorization type for the endpoint.</p>"""
+    auto_deployment_mode: NotRequired[
+        "capo_lambda_web.types.auto_deployment_mode.AutoDeploymentMode"
+    ]
+    """<p>The auto-deployment mode for the endpoint.</p>"""
+    revision_weights: NotRequired[
+        "capo_lambda_web.types.revision_weight_list.RevisionWeightList"
+    ]
+    """<p>A list of revision weights that determine how traffic is distributed across revisions.</p>"""
+    scaling_config: NotRequired["capo_lambda_web.types.scaling_config.ScalingConfig"]
+    """<p>The scaling configuration for the endpoint. Omit this field to keep the current scaling configuration. To clear a previously set <code>maxEnvironments</code> value, specify an empty object.</p>"""
+    throttle_config: NotRequired["capo_lambda_web.types.throttle_config.ThrottleConfig"]
+    """<p>The throttling configuration for the endpoint. Omit this field to keep the current throttling configuration. To clear a previously set <code>rateLimit</code> value, specify an empty object.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpdateWebFunctionEndpointRequest) -> dict:
+    out: dict = {}
+    if "description" in value:
+        out["description"] = value["description"]
+    if "auth_type" in value:
+        import capo_lambda_web.types.auth_type
+
+        out["authType"] = capo_lambda_web.types.auth_type.serialize_json(
+            value["auth_type"]
+        )
+    if "auto_deployment_mode" in value:
+        import capo_lambda_web.types.auto_deployment_mode
+
+        out["autoDeploymentMode"] = (
+            capo_lambda_web.types.auto_deployment_mode.serialize_json(
+                value["auto_deployment_mode"]
+            )
+        )
+    if "revision_weights" in value:
+        import capo_lambda_web.types.revision_weight_list
+
+        out["revisionWeights"] = (
+            capo_lambda_web.types.revision_weight_list.serialize_json(
+                value["revision_weights"]
+            )
+        )
+    if "scaling_config" in value:
+        import capo_lambda_web.types.scaling_config
+
+        out["scalingConfig"] = capo_lambda_web.types.scaling_config.serialize_json(
+            value["scaling_config"]
+        )
+    if "throttle_config" in value:
+        import capo_lambda_web.types.throttle_config
+
+        out["throttleConfig"] = capo_lambda_web.types.throttle_config.serialize_json(
+            value["throttle_config"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> UpdateWebFunctionEndpointRequest:
+    out: UpdateWebFunctionEndpointRequest = {}  # type: ignore[typeddict-item]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("authType") is not None:
+        import capo_lambda_web.types.auth_type
+
+        out["auth_type"] = capo_lambda_web.types.auth_type.deserialize_json(
+            data["authType"]
+        )
+    if data.get("autoDeploymentMode") is not None:
+        import capo_lambda_web.types.auto_deployment_mode
+
+        out["auto_deployment_mode"] = (
+            capo_lambda_web.types.auto_deployment_mode.deserialize_json(
+                data["autoDeploymentMode"]
+            )
+        )
+    if data.get("revisionWeights") is not None:
+        import capo_lambda_web.types.revision_weight_list
+
+        out["revision_weights"] = (
+            capo_lambda_web.types.revision_weight_list.deserialize_json(
+                data["revisionWeights"]
+            )
+        )
+    if data.get("scalingConfig") is not None:
+        import capo_lambda_web.types.scaling_config
+
+        out["scaling_config"] = capo_lambda_web.types.scaling_config.deserialize_json(
+            data["scalingConfig"]
+        )
+    if data.get("throttleConfig") is not None:
+        import capo_lambda_web.types.throttle_config
+
+        out["throttle_config"] = capo_lambda_web.types.throttle_config.deserialize_json(
+            data["throttleConfig"]
+        )
+    return out