localstack-core 4.7.1.dev23__py3-none-any.whl → 4.7.1.dev24__py3-none-any.whl

localstack/aws/handlers/service.py

@@ -3,7 +3,7 @@
 import logging
 import traceback
 from collections import defaultdict
-from typing import Any, Dict, Union
+from typing import Any
 
 from botocore.model import OperationModel, ServiceModel
 
@@ -49,7 +49,7 @@ class ServiceRequestParser(Handler):
     already be resolved in the RequestContext (e.g., through a ServiceNameParser)
     """
 
-    parsers: Dict[str, RequestParser]
+    parsers: dict[str, RequestParser]
 
     def __init__(self):
         self.parsers = dict()
@@ -89,7 +89,7 @@ class ServiceRequestRouter(Handler):
     Routes ServiceOperations to Handlers.
     """
 
-    handlers: Dict[ServiceOperation, Handler]
+    handlers: dict[ServiceOperation, Handler]
 
     def __init__(self):
         self.handlers = dict()
@@ -118,7 +118,7 @@ class ServiceRequestRouter(Handler):
 
         self.handlers[key] = handler
 
-    def add_provider(self, provider: Any, service: Union[str, ServiceModel]):
+    def add_provider(self, provider: Any, service: str | ServiceModel):
         self.add_skeleton(create_skeleton(service, provider))
 
     def add_skeleton(self, skeleton: Skeleton):
@@ -278,7 +278,7 @@ class ServiceResponseHandlers(Handler):
     are only called if the request context has a service, and there are handlers for that particular service.
     """
 
-    handlers: Dict[str, CompositeResponseHandler]
+    handlers: dict[str, CompositeResponseHandler]
 
     def __init__(self):
         self.handlers = defaultdict(CompositeResponseHandler)

localstack/aws/mocking.py

@@ -4,7 +4,7 @@ import random
 import re
 from datetime import date, datetime
 from functools import lru_cache, singledispatch
-from typing import Dict, List, Optional, Set, Tuple, Union, cast
+from typing import cast
 
 import botocore
 import networkx
@@ -32,18 +32,9 @@ types = {
     "boolean",
 }
 
-Instance = Union[
-    Dict[str, "Instance"],
-    List["Instance"],
-    str,
-    bytes,
-    map,
-    list,
-    float,
-    int,
-    bool,
-    date,
-]
+Instance = (
+    dict[str, "Instance"] | list["Instance"] | str | bytes | map | list | float | int | bool | date
+)
 
 # https://github.com/boto/botocore/issues/2623
 StringShape.METADATA_ATTRS.append("pattern")
@@ -66,14 +57,14 @@ DEFAULT_ARN = "arn:aws:ec2:us-east-1:1234567890123:instance/i-abcde0123456789f"
 
 
 class ShapeGraph(networkx.DiGraph):
-    root: Union[ListShape, StructureShape, MapShape]
-    cycle: List[Tuple[str, str]]
-    cycle_shapes: List[str]
+    root: ListShape | StructureShape | MapShape
+    cycle: list[tuple[str, str]]
+    cycle_shapes: list[str]
 
 
 def populate_graph(graph: networkx.DiGraph, root: Shape):
-    stack: List[Shape] = [root]
-    visited: Set[str] = set()
+    stack: list[Shape] = [root]
+    visited: set[str] = set()
 
     while stack:
         cur = stack.pop()
@@ -230,14 +221,14 @@ custom_arns = {
 
 
 @singledispatch
-def generate_instance(shape: Shape, graph: ShapeGraph) -> Optional[Instance]:
+def generate_instance(shape: Shape, graph: ShapeGraph) -> Instance | None:
     if shape is None:
         return None
     raise ValueError("could not generate shape for type %s" % shape.type_name)
 
 
 @generate_instance.register
-def _(shape: StructureShape, graph: ShapeGraph) -> Dict[str, Instance]:
+def _(shape: StructureShape, graph: ShapeGraph) -> dict[str, Instance]:
     if shape.is_tagged_union:
         k, v = random.choice(list(shape.members.items()))
         members = {k: v}
@@ -255,14 +246,14 @@ def _(shape: StructureShape, graph: ShapeGraph) -> Dict[str, Instance]:
 
 
 @generate_instance.register
-def _(shape: ListShape, graph: ShapeGraph) -> List[Instance]:
+def _(shape: ListShape, graph: ShapeGraph) -> list[Instance]:
     if shape.name in graph.cycle_shapes:
         return []
     return [generate_instance(shape.member, graph) for _ in range(shape.metadata.get("min", 1))]
 
 
 @generate_instance.register
-def _(shape: MapShape, graph: ShapeGraph) -> Dict[str, Instance]:
+def _(shape: MapShape, graph: ShapeGraph) -> dict[str, Instance]:
     if shape.name in graph.cycle_shapes:
         return {}
     return {generate_instance(shape.key, graph): generate_instance(shape.value, graph)}
@@ -379,7 +370,7 @@ def _(shape: StringShape, graph: ShapeGraph) -> str:
 
 
 @generate_instance.register
-def _(shape: Shape, graph: ShapeGraph) -> Union[int, float, bool, bytes, date]:
+def _(shape: Shape, graph: ShapeGraph) -> int | float | bool | bytes | date:
     if shape.type_name in ["integer", "long"]:
         return shape.metadata.get("min", 1)
     if shape.type_name in ["float", "double"]:
@@ -427,7 +418,7 @@ def create_mocking_dispatch_table(service) -> DispatchTable:
     return dispatch_table
 
 
-@lru_cache()
+@lru_cache
 def get_mocking_skeleton(service: str) -> Skeleton:
     service = load_service(service)
     return Skeleton(service, create_mocking_dispatch_table(service))

localstack/aws/protocol/op_router.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
-from typing import Any, Dict, List, Mapping, NamedTuple, Optional, Tuple
+from collections.abc import Mapping
+from typing import Any, NamedTuple
 from urllib.parse import parse_qs, unquote
 
 from botocore.model import OperationModel, ServiceModel, StructureShape
@@ -24,8 +25,8 @@ class _HttpOperation(NamedTuple):
     operation: OperationModel
     path: str
     method: str
-    query_args: Mapping[str, List[str]]
-    header_args: List[str]
+    query_args: Mapping[str, list[str]]
+    header_args: list[str]
     deprecated: bool
 
     @staticmethod
@@ -49,11 +50,11 @@ class _HttpOperation(NamedTuple):
         path_query = uri.split("?")
         path = path_query[0]
         header_args = []
-        query_args: Dict[str, List[str]] = {}
+        query_args: dict[str, list[str]] = {}
 
         if len(path_query) > 1:
             # parse the query args of the request URI (they are mandatory)
-            query_args: Dict[str, List[str]] = parse_qs(path_query[1], keep_blank_values=True)
+            query_args: dict[str, list[str]] = parse_qs(path_query[1], keep_blank_values=True)
             # for mandatory keys without values, keep an empty list (instead of [''] - the result of parse_qs)
             query_args = {k: filter(None, v) for k, v in query_args.items()}
 
@@ -85,8 +86,8 @@ class _RequiredArgsRule:
     """
 
     endpoint: Any
-    required_query_args: Optional[Mapping[str, List[Any]]]
-    required_header_args: List[str]
+    required_query_args: Mapping[str, list[Any]] | None
+    required_header_args: list[str]
     match_score: int
 
     def __init__(self, operation: _HttpOperation) -> None:
@@ -139,7 +140,7 @@ class _RequestMatchingRule(StrictMethodRule):
     """
 
     def __init__(
-        self, string: str, operations: List[_HttpOperation], method: str, **kwargs
+        self, string: str, operations: list[_HttpOperation], method: str, **kwargs
     ) -> None:
         super().__init__(string=string, method=method, **kwargs)
         # Create a rule which checks all required arguments (not only the path and method)
@@ -174,7 +175,7 @@ def _create_service_map(service: ServiceModel) -> Map:
     rules = []
 
     # group all operations by their path and method
-    path_index: Dict[(str, str), List[_HttpOperation]] = defaultdict(list)
+    path_index: dict[(str, str), list[_HttpOperation]] = defaultdict(list)
     for op in ops:
         http_op = _HttpOperation.from_operation(op)
         path_index[(http_op.path, http_op.method)].append(http_op)
@@ -216,7 +217,7 @@ class RestServiceOperationRouter:
     def __init__(self, service: ServiceModel):
         self._map = _create_service_map(service)
 
-    def match(self, request: Request) -> Tuple[OperationModel, Mapping[str, Any]]:
+    def match(self, request: Request) -> tuple[OperationModel, Mapping[str, Any]]:
         """
         Matches the given request to the operation it targets (or raises an exception if no operation matches).
 

localstack/aws/protocol/parser.py

@@ -68,8 +68,9 @@ import datetime
 import functools
 import re
 from abc import ABC
+from collections.abc import Mapping
 from email.utils import parsedate_to_datetime
-from typing import IO, Any, Dict, List, Mapping, Optional, Tuple, Union
+from typing import IO, Any
 from xml.etree import ElementTree as ETree
 
 import dateutil.parser
@@ -107,7 +108,7 @@ def _text_content(func):
         self,
         request: Request,
         shape: Shape,
-        node_or_string: Union[ETree.Element, str],
+        node_or_string: ETree.Element | str,
         uri_params: Mapping[str, Any] = None,
     ):
         if hasattr(node_or_string, "text"):
@@ -203,7 +204,7 @@ class RequestParser(abc.ABC):
         self.service = service
 
     @_handle_exceptions
-    def parse(self, request: Request) -> Tuple[OperationModel, Any]:
+    def parse(self, request: Request) -> tuple[OperationModel, Any]:
         """
         Determines which operation the request was aiming for and parses the incoming request such that the resulting
         dictionary can be used to invoke the service's function implementation.
@@ -367,7 +368,7 @@ class QueryRequestParser(RequestParser):
     """
 
     @_handle_exceptions
-    def parse(self, request: Request) -> Tuple[OperationModel, Any]:
+    def parse(self, request: Request) -> tuple[OperationModel, Any]:
         instance = request.values
         if "Action" not in instance:
             raise ProtocolParserError(
@@ -510,7 +511,7 @@ class QueryRequestParser(RequestParser):
 
         # We collect the list value as well as the integer indicating the list position so we can
         # later sort the list by the position, in case they attribute values are unordered
-        result: List[Tuple[int, Any]] = []
+        result: list[tuple[int, Any]] = []
 
         i = 0
         while True:
@@ -559,7 +560,7 @@ class BaseRestRequestParser(RequestParser):
         self._operation_router = RestServiceOperationRouter(service)
 
     @_handle_exceptions
-    def parse(self, request: Request) -> Tuple[OperationModel, Any]:
+    def parse(self, request: Request) -> tuple[OperationModel, Any]:
         try:
             operation, uri_params = self._operation_router.match(request)
         except NotFound as e:
@@ -578,7 +579,7 @@ class BaseRestRequestParser(RequestParser):
         self,
         request: Request,
         shape: Shape,
-        member_shapes: Dict[str, Shape],
+        member_shapes: dict[str, Shape],
         uri_params: Mapping[str, Any],
         final_parsed: dict,
     ) -> None:
@@ -781,7 +782,7 @@ class RestXMLRequestParser(BaseRestRequestParser):
             ) from e
         return root
 
-    def _build_name_to_xml_node(self, parent_node: Union[list, ETree.Element]) -> dict:
+    def _build_name_to_xml_node(self, parent_node: list | ETree.Element) -> dict:
         # If the parent node is actually a list. We should not be trying
         # to serialize it to a dictionary. Instead, return the first element
         # in the list.
@@ -824,9 +825,9 @@ class BaseJSONRequestParser(RequestParser, ABC):
         self,
         request: Request,
         shape: StructureShape,
-        value: Optional[dict],
+        value: dict | None,
         uri_params: Mapping[str, Any] = None,
-    ) -> Optional[dict]:
+    ) -> dict | None:
         if shape.is_document_type:
             final_parsed = value
         else:
@@ -849,9 +850,9 @@ class BaseJSONRequestParser(RequestParser, ABC):
         self,
         request: Request,
         shape: MapShape,
-        value: Optional[dict],
+        value: dict | None,
         uri_params: Mapping[str, Any] = None,
-    ) -> Optional[dict]:
+    ) -> dict | None:
         if value is None:
             return None
         parsed = {}
@@ -916,7 +917,7 @@ class JSONRequestParser(BaseJSONRequestParser):
     """
 
     @_handle_exceptions
-    def parse(self, request: Request) -> Tuple[OperationModel, Any]:
+    def parse(self, request: Request) -> tuple[OperationModel, Any]:
         target = request.headers["X-Amz-Target"]
         # assuming that the last part of the target string (e.g., "x.y.z.MyAction") contains the operation name
         operation_name = target.rpartition(".")[2]
@@ -1038,9 +1039,7 @@ class S3RequestParser(RestXMLRequestParser):
                 )
 
         @staticmethod
-        def _set_request_props(
-            request: Request, path: str, host: str, raw_uri: Optional[str] = None
-        ):
+        def _set_request_props(request: Request, path: str, host: str, raw_uri: str | None = None):
             """Sets the HTTP request's path and host and clears the cache in the request object."""
             request.path = path
             request.headers["Host"] = host
@@ -1072,7 +1071,7 @@ class S3RequestParser(RestXMLRequestParser):
             return uses_host_addressing(request.headers)
 
     @_handle_exceptions
-    def parse(self, request: Request) -> Tuple[OperationModel, Any]:
+    def parse(self, request: Request) -> tuple[OperationModel, Any]:
         """Handle virtual-host-addressing for S3."""
         with self.VirtualHostRewriter(request):
             return super().parse(request)

localstack/aws/protocol/serializer.py

@@ -79,10 +79,11 @@ import logging
 import string
 from abc import ABC
 from binascii import crc32
+from collections.abc import Iterable, Iterator
 from datetime import datetime
 from email.utils import formatdate
 from struct import pack
-from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Union
+from typing import Any
 from xml.etree import ElementTree as ETree
 
 import xmltodict
@@ -181,14 +182,14 @@ class ResponseSerializer(abc.ABC):
     AWS_BINARY_DATA_TYPE_STRING = 7
     # Defines the supported mime types of the specific serializer. Sorted by priority (preferred / default first).
     # Needs to be specified by subclasses.
-    SUPPORTED_MIME_TYPES: List[str] = []
+    SUPPORTED_MIME_TYPES: list[str] = []
 
     @_handle_exceptions
     def serialize_to_response(
         self,
         response: dict,
         operation_model: OperationModel,
-        headers: Optional[Dict | Headers],
+        headers: dict | Headers | None,
         request_id: str,
     ) -> Response:
         """
@@ -234,7 +235,7 @@ class ResponseSerializer(abc.ABC):
         self,
         error: ServiceException,
         operation_model: OperationModel,
-        headers: Optional[Dict | Headers],
+        headers: dict | Headers | None,
         request_id: str,
     ) -> Response:
         """
@@ -274,7 +275,7 @@ class ResponseSerializer(abc.ABC):
         self,
         parameters: dict,
         response: Response,
-        shape: Optional[Shape],
+        shape: Shape | None,
         shape_members: dict,
         operation_model: OperationModel,
         mime_type: str,
@@ -289,7 +290,7 @@ class ResponseSerializer(abc.ABC):
         operation_model: OperationModel,
         mime_type: str,
         request_id: str,
-    ) -> Optional[str]:
+    ) -> str | None:
         """
         Actually serializes the given params for the given shape to a string for the transmission in the body of the
         response.
@@ -390,9 +391,9 @@ class ResponseSerializer(abc.ABC):
     def _encode_event_payload(
         self,
         event_type: str,
-        content: Union[str, bytes] = "",
-        error_code: Optional[str] = None,
-        error_message: Optional[str] = None,
+        content: str | bytes = "",
+        error_code: str | None = None,
+        error_message: str | None = None,
     ) -> bytes:
         """
         Encodes the given event payload according to AWS specific binary event encoding.
@@ -469,7 +470,7 @@ class ResponseSerializer(abc.ABC):
         """
         return Response(status=operation_model.http.get("responseCode", 200))
 
-    def _get_mime_type(self, headers: Optional[Dict | Headers]) -> str:
+    def _get_mime_type(self, headers: dict | Headers | None) -> str:
         """
         Extracts the accepted mime type from the request headers and returns a matching, supported mime type for the
         serializer or the default mime type of the service if there is no match.
@@ -521,9 +522,7 @@ class ResponseSerializer(abc.ABC):
             value = self._timestamp_unixtimestamp(value)
         return formatdate(value, usegmt=True)
 
-    def _convert_timestamp_to_str(
-        self, value: Union[int, str, datetime], timestamp_format=None
-    ) -> str:
+    def _convert_timestamp_to_str(self, value: int | str | datetime, timestamp_format=None) -> str:
         if timestamp_format is None:
             timestamp_format = self.TIMESTAMP_FORMAT
         timestamp_format = timestamp_format.lower()
@@ -540,7 +539,7 @@ class ResponseSerializer(abc.ABC):
         """
         return shape.serialization.get("name", default_name)
 
-    def _get_base64(self, value: Union[str, bytes]):
+    def _get_base64(self, value: str | bytes):
         """
         Returns the base64-encoded version of value, handling
         both strings and bytes. The returned value is a string
@@ -550,7 +549,7 @@ class ResponseSerializer(abc.ABC):
             value = value.encode(self.DEFAULT_ENCODING)
         return base64.b64encode(value).strip().decode(self.DEFAULT_ENCODING)
 
-    def _encode_payload(self, body: Union[bytes, str]) -> bytes:
+    def _encode_payload(self, body: bytes | str) -> bytes:
         if isinstance(body, str):
             return body.encode(self.DEFAULT_ENCODING)
         return body
@@ -578,7 +577,7 @@ class ResponseSerializer(abc.ABC):
             md5_digest = calculate_md5(body)
             headers["Content-MD5"] = md5_digest
 
-    def _get_error_message(self, error: Exception) -> Optional[str]:
+    def _get_error_message(self, error: Exception) -> str | None:
         return str(error) if error is not None and str(error) != "None" else None
 
 
@@ -661,14 +660,14 @@ class BaseXMLResponseSerializer(ResponseSerializer):
         operation_model: OperationModel,
         mime_type: str,
         request_id: str,
-    ) -> Optional[str]:
+    ) -> str | None:
         root = self._serialize_body_params_to_xml(params, shape, operation_model, mime_type)
         self._prepare_additional_traits_in_xml(root, request_id)
         return self._node_to_string(root, mime_type)
 
     def _serialize_body_params_to_xml(
         self, params: dict, shape: Shape, operation_model: OperationModel, mime_type: str
-    ) -> Optional[ETree.Element]:
+    ) -> ETree.Element | None:
         if shape is None:
             return
         # The botocore serializer expects `shape.serialization["name"]`, but this isn't always present for responses
@@ -812,7 +811,7 @@ class BaseXMLResponseSerializer(ResponseSerializer):
         node.text = str_value
 
     def _serialize_type_blob(
-        self, xmlnode: ETree.Element, params: Union[str, bytes], _, name: str, __
+        self, xmlnode: ETree.Element, params: str | bytes, _, name: str, __
     ) -> None:
         node = ETree.SubElement(xmlnode, name)
         node.text = self._get_base64(params)
@@ -838,7 +837,7 @@ class BaseXMLResponseSerializer(ResponseSerializer):
         node = ETree.SubElement(xmlnode, name)
         node.text = str(params)
 
-    def _prepare_additional_traits_in_xml(self, root: Optional[ETree.Element], request_id: str):
+    def _prepare_additional_traits_in_xml(self, root: ETree.Element | None, request_id: str):
         """
         Prepares the XML root node before being serialized with additional traits (like the Response ID in the Query
         protocol).
@@ -851,7 +850,7 @@ class BaseXMLResponseSerializer(ResponseSerializer):
         response.headers["Content-Type"] = mime_type
         return response
 
-    def _node_to_string(self, root: Optional[ETree.Element], mime_type: str) -> Optional[str]:
+    def _node_to_string(self, root: ETree.Element | None, mime_type: str) -> str | None:
         """Generates the string representation of the given XML element."""
         if root is not None:
             content = ETree.tostring(
@@ -877,7 +876,7 @@ class BaseRestResponseSerializer(ResponseSerializer, ABC):
         self,
         parameters: dict,
         response: Response,
-        shape: Optional[Shape],
+        shape: Shape | None,
         shape_members: dict,
         operation_model: OperationModel,
         mime_type: str,
@@ -904,7 +903,7 @@ class BaseRestResponseSerializer(ResponseSerializer, ABC):
         self,
         parameters: dict,
         response: Response,
-        shape: Optional[Shape],
+        shape: Shape | None,
         shape_members: dict,
         operation_model: OperationModel,
         mime_type: str,
@@ -975,7 +974,7 @@ class BaseRestResponseSerializer(ResponseSerializer, ABC):
         """
         pass
 
-    def _has_streaming_payload(self, payload: Optional[str], shape_members):
+    def _has_streaming_payload(self, payload: str | None, shape_members):
         """Determine if payload is streaming (a blob or string)."""
         return payload is not None and shape_members[payload].type_name in ["blob", "string"]
 
@@ -1040,7 +1039,7 @@ class BaseRestResponseSerializer(ResponseSerializer, ABC):
         else:
             return value
 
-    def _partition_members(self, parameters: dict, shape: Optional[Shape]) -> Tuple[dict, dict]:
+    def _partition_members(self, parameters: dict, shape: Shape | None) -> tuple[dict, dict]:
         """Separates the top-level keys in the given parameters dict into header- and payload-located params."""
         if not isinstance(shape, StructureShape):
             # If the shape isn't a structure, we default to the whole response being parsed in the body.
@@ -1083,7 +1082,7 @@ class QueryResponseSerializer(BaseXMLResponseSerializer):
         self,
         parameters: dict,
         response: Response,
-        shape: Optional[Shape],
+        shape: Shape | None,
         shape_members: dict,
         operation_model: OperationModel,
         mime_type: str,
@@ -1130,7 +1129,7 @@ class QueryResponseSerializer(BaseXMLResponseSerializer):
             root.append(node)
         return root
 
-    def _prepare_additional_traits_in_xml(self, root: Optional[ETree.Element], request_id: str):
+    def _prepare_additional_traits_in_xml(self, root: ETree.Element | None, request_id: str):
         # Add the response metadata here (it's not defined in the specs)
         # For the ec2 and the query protocol, the root cannot be None at this time.
         response_metadata = ETree.SubElement(root, "ResponseMetadata")
@@ -1179,7 +1178,7 @@ class EC2ResponseSerializer(QueryResponseSerializer):
         request_id_element.text = request_id
         response.set_response(self._encode_payload(self._node_to_string(root, mime_type)))
 
-    def _prepare_additional_traits_in_xml(self, root: Optional[ETree.Element], request_id: str):
+    def _prepare_additional_traits_in_xml(self, root: ETree.Element | None, request_id: str):
         # The EC2 protocol does not use the root output shape, therefore we need to remove the hierarchy level
         # below the root level
         if len(root) > 0:
@@ -1251,7 +1250,7 @@ class JSONResponseSerializer(ResponseSerializer):
         self,
         parameters: dict,
         response: Response,
-        shape: Optional[Shape],
+        shape: Shape | None,
         shape_members: dict,
         operation_model: OperationModel,
         mime_type: str,
@@ -1274,7 +1273,7 @@ class JSONResponseSerializer(ResponseSerializer):
         operation_model: OperationModel,
         mime_type: str,
         request_id: str,
-    ) -> Optional[str]:
+    ) -> str | None:
         body = {}
         if shape is not None:
             self._serialize(body, params, shape, None, mime_type)
@@ -1284,7 +1283,7 @@ class JSONResponseSerializer(ResponseSerializer):
         else:
             return json.dumps(body)
 
-    def _serialize(self, body: dict, value: Any, shape, key: Optional[str], mime_type: str):
+    def _serialize(self, body: dict, value: Any, shape, key: str | None, mime_type: str):
         """This method dynamically invokes the correct `_serialize_type_*` method for each shape type."""
         try:
             method = getattr(self, "_serialize_type_%s" % shape.type_name, self._default_serialize)
@@ -1295,7 +1294,7 @@ class JSONResponseSerializer(ResponseSerializer):
             ) from e
 
     def _serialize_type_structure(
-        self, body: dict, value: dict, shape: StructureShape, key: Optional[str], mime_type: str
+        self, body: dict, value: dict, shape: StructureShape, key: str | None, mime_type: str
     ):
         if value is None:
             return
@@ -1369,9 +1368,7 @@ class JSONResponseSerializer(ResponseSerializer):
             timestamp_format = shape.serialization.get("timestampFormat")
             body[key] = self._convert_timestamp_to_str(value, timestamp_format)
 
-    def _serialize_type_blob(
-        self, body: dict, value: Union[str, bytes], _, key: str, mime_type: str
-    ):
+    def _serialize_type_blob(self, body: dict, value: str | bytes, _, key: str, mime_type: str):
         if mime_type in self.CBOR_TYPES:
             body[key] = value
         else:
@@ -1466,7 +1463,7 @@ class S3ResponseSerializer(RestXMLResponseSerializer):
         self,
         parameters: dict,
         response: Response,
-        shape: Optional[Shape],
+        shape: Shape | None,
         shape_members: dict,
         operation_model: OperationModel,
         mime_type: str,
@@ -1528,7 +1525,7 @@ class S3ResponseSerializer(RestXMLResponseSerializer):
         operation_model: OperationModel,
         mime_type: str,
         request_id: str,
-    ) -> Optional[str]:
+    ) -> str | None:
         root = self._serialize_body_params_to_xml(params, shape, operation_model, mime_type)
         # S3 does not follow the specs on the root tag name for 41 of 44 operations
         root.tag = self._RESPONSE_ROOT_TAGS.get(root.tag, root.tag)
@@ -1568,7 +1565,7 @@ class S3ResponseSerializer(RestXMLResponseSerializer):
     def _create_empty_node(xmlnode: ETree.Element, name: str) -> None:
         ETree.SubElement(xmlnode, name)
 
-    def _prepare_additional_traits_in_xml(self, root: Optional[ETree.Element], request_id: str):
+    def _prepare_additional_traits_in_xml(self, root: ETree.Element | None, request_id: str):
         # some tools (Serverless) require a newline after the "<?xml ...>\n" preamble line, e.g., for LocationConstraint
         if root and not root.tail:
             root.tail = "\n"
@@ -1639,7 +1636,7 @@ class SqsQueryResponseSerializer(QueryResponseSerializer):
             .replace("\r", "__marker__-r__marker__")
         )
 
-    def _node_to_string(self, root: Optional[ETree.ElementTree], mime_type: str) -> Optional[str]:
+    def _node_to_string(self, root: ETree.ElementTree | None, mime_type: str) -> str | None:
         """Replaces the previously "marked" characters with their encoded value."""
         generated_string = super()._node_to_string(root, mime_type)
         if generated_string is None:
@@ -1785,7 +1782,7 @@ def create_serializer(service: ServiceModel) -> ResponseSerializer:
 
 
 def aws_response_serializer(
-    service_name: str, operation: str, protocol: Optional[ProtocolName] = None
+    service_name: str, operation: str, protocol: ProtocolName | None = None
 ):
     """
     A decorator for an HTTP route that can serialize return values or exceptions into AWS responses.