botocore 1.34.146__py3-none-any.whl → 1.34.148__py3-none-any.whl

botocore/errorfactory.py

@@ -49,8 +49,8 @@ class BaseClientExceptions:
             for exception_cls in self._code_to_exception.values()
         ]
         raise AttributeError(
-            fr"{self} object has no attribute {name}. "
-            fr"Valid exceptions are: {', '.join(exception_cls_names)}"
+            rf"{self} object has no attribute {name}. "
+            rf"Valid exceptions are: {', '.join(exception_cls_names)}"
         )
 
 

botocore/eventstream.py

@@ -10,7 +10,7 @@
 # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
-"""Binary Event Stream Decoding """
+"""Binary Event Stream Decoding"""
 
 from binascii import crc32
 from struct import unpack
@@ -33,7 +33,7 @@ class DuplicateHeader(ParserError):
     """Duplicate header found in the event."""
 
     def __init__(self, header):
-        message = 'Duplicate header present: "%s"' % header
+        message = f'Duplicate header present: "{header}"'
         super().__init__(message)
 
 
@@ -41,10 +41,7 @@ class InvalidHeadersLength(ParserError):
     """Headers length is longer than the maximum."""
 
     def __init__(self, length):
-        message = 'Header length of {} exceeded the maximum of {}'.format(
-            length,
-            _MAX_HEADERS_LENGTH,
-        )
+        message = f'Header length of {length} exceeded the maximum of {_MAX_HEADERS_LENGTH}'
         super().__init__(message)
 
 
@@ -52,10 +49,7 @@ class InvalidPayloadLength(ParserError):
     """Payload length is longer than the maximum."""
 
     def __init__(self, length):
-        message = 'Payload length of {} exceeded the maximum of {}'.format(
-            length,
-            _MAX_PAYLOAD_LENGTH,
-        )
+        message = f'Payload length of {length} exceeded the maximum of {_MAX_PAYLOAD_LENGTH}'
         super().__init__(message)
 
 
@@ -63,12 +57,7 @@ class ChecksumMismatch(ParserError):
     """Calculated checksum did not match the expected checksum."""
 
     def __init__(self, expected, calculated):
-        message = (
-            'Checksum mismatch: expected 0x{:08x}, calculated 0x{:08x}'.format(
-                expected,
-                calculated,
-            )
-        )
+        message = f'Checksum mismatch: expected 0x{expected:08x}, calculated 0x{calculated:08x}'
         super().__init__(message)
 
 

botocore/handlers.py

@@ -251,8 +251,7 @@ def generate_idempotent_uuid(params, model, **kwargs):
         if name not in params:
             params[name] = str(uuid.uuid4())
             logger.debug(
-                "injecting idempotency token (%s) into param '%s'."
-                % (params[name], name)
+                f"injecting idempotency token ({params[name]}) into param '{name}'."
             )
 
 
@@ -454,7 +453,7 @@ def _quote_source_header_from_dict(source_dict):
         )
     final = percent_encode(final, safe=SAFE_CHARS + '/')
     if version_id is not None:
-        final += '?versionId=%s' % version_id
+        final += f'?versionId={version_id}'
     return final
 
 
@@ -632,8 +631,8 @@ def validate_ascii_metadata(params, **kwargs):
         except UnicodeEncodeError:
             error_msg = (
                 'Non ascii characters found in S3 metadata '
-                'for key "%s", value: "%s".  \nS3 metadata can only '
-                'contain ASCII characters. ' % (key, value)
+                f'for key "{key}", value: "{value}".  \nS3 metadata can only '
+                'contain ASCII characters. '
             )
             raise ParamValidationError(report=error_msg)
 
@@ -761,10 +760,10 @@ def check_openssl_supports_tls_version_1_2(**kwargs):
         openssl_version_tuple = ssl.OPENSSL_VERSION_INFO
         if openssl_version_tuple < (1, 0, 1):
             warnings.warn(
-                'Currently installed openssl version: %s does not '
+                f'Currently installed openssl version: {ssl.OPENSSL_VERSION} does not '
                 'support TLS 1.2, which is required for use of iot-data. '
                 'Please use python installed with openssl version 1.0.1 or '
-                'higher.' % (ssl.OPENSSL_VERSION),
+                'higher.',
                 UnsupportedTLSVersionWarning,
             )
     # We cannot check the openssl version on python2.6, so we should just

botocore/hooks.py

@@ -170,7 +170,7 @@ class BaseEventHooks:
 
     def _verify_is_callable(self, func):
         if not callable(func):
-            raise ValueError("Event handler %s must be callable." % func)
+            raise ValueError(f"Event handler {func} must be callable.")
 
     def _verify_accept_kwargs(self, func):
         """Verifies a callable accepts kwargs
@@ -314,20 +314,20 @@ class HierarchicalEmitter(BaseEventHooks):
                 if unique_id_uses_count:
                     if not count:
                         raise ValueError(
-                            "Initial registration of  unique id %s was "
+                            f"Initial registration of  unique id {unique_id} was "
                             "specified to use a counter. Subsequent register "
                             "calls to unique id must specify use of a counter "
-                            "as well." % unique_id
+                            "as well."
                         )
                     else:
                         self._unique_id_handlers[unique_id]['count'] += 1
                 else:
                     if count:
                         raise ValueError(
-                            "Initial registration of unique id %s was "
+                            f"Initial registration of unique id {unique_id} was "
                             "specified to not use a counter. Subsequent "
                             "register calls to unique id must specify not to "
-                            "use a counter as well." % unique_id
+                            "use a counter as well."
                         )
                 return
             else:
@@ -364,9 +364,9 @@ class HierarchicalEmitter(BaseEventHooks):
             if unique_id_uses_count:
                 if count is None:
                     raise ValueError(
-                        "Initial registration of unique id %s was specified to "
+                        f"Initial registration of unique id {unique_id} was specified to "
                         "use a counter. Subsequent unregister calls to unique "
-                        "id must specify use of a counter as well." % unique_id
+                        "id must specify use of a counter as well."
                     )
                 elif count == 1:
                     handler = self._unique_id_handlers.pop(unique_id)[
@@ -378,10 +378,10 @@ class HierarchicalEmitter(BaseEventHooks):
             else:
                 if count:
                     raise ValueError(
-                        "Initial registration of unique id %s was specified "
+                        f"Initial registration of unique id {unique_id} was specified "
                         "to not use a counter. Subsequent unregister calls "
                         "to unique id must specify not to use a counter as "
-                        "well." % unique_id
+                        "well."
                     )
                 handler = self._unique_id_handlers.pop(unique_id)['handler']
         try:

botocore/httpchecksum.py

@@ -11,13 +11,14 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-""" The interfaces in this module are not intended for public use.
+"""The interfaces in this module are not intended for public use.
 
 This module defines interfaces for applying checksums to HTTP requests within
 the context of botocore. This involves both resolving the checksum to be used
 based on client configuration and environment, as well as application of the
 checksum to the request.
 """
+
 import base64
 import io
 import logging
@@ -264,7 +265,7 @@ def resolve_request_checksum_algorithm(
                     )
                 )
             raise FlexibleChecksumError(
-                error_msg="Unsupported checksum algorithm: %s" % algorithm_name
+                error_msg=f"Unsupported checksum algorithm: {algorithm_name}"
             )
 
         location_type = "header"
@@ -278,7 +279,7 @@ def resolve_request_checksum_algorithm(
         algorithm = {
             "algorithm": algorithm_name,
             "in": location_type,
-            "name": "x-amz-checksum-%s" % algorithm_name,
+            "name": f"x-amz-checksum-{algorithm_name}",
         }
 
         if algorithm["name"] in request["headers"]:
@@ -313,7 +314,7 @@ def apply_request_checksum(request):
         _apply_request_trailer_checksum(request)
     else:
         raise FlexibleChecksumError(
-            error_msg="Unknown checksum variant: %s" % algorithm["in"]
+            error_msg="Unknown checksum variant: {}".format(algorithm["in"])
         )
 
 
@@ -400,7 +401,7 @@ def handle_checksum_body(http_response, response, context, operation_model):
         return
 
     for algorithm in algorithms:
-        header_name = "x-amz-checksum-%s" % algorithm
+        header_name = f"x-amz-checksum-{algorithm}"
         # If the header is not found, check the next algorithm
         if header_name not in headers:
             continue
@@ -434,7 +435,7 @@ def handle_checksum_body(http_response, response, context, operation_model):
 
 def _handle_streaming_response(http_response, response, algorithm):
     checksum_cls = _CHECKSUM_CLS.get(algorithm)
-    header_name = "x-amz-checksum-%s" % algorithm
+    header_name = f"x-amz-checksum-{algorithm}"
     return StreamingChecksumBody(
         http_response.raw,
         response["headers"].get("content-length"),
@@ -445,18 +446,15 @@ def _handle_streaming_response(http_response, response, algorithm):
 
 def _handle_bytes_response(http_response, response, algorithm):
     body = http_response.content
-    header_name = "x-amz-checksum-%s" % algorithm
+    header_name = f"x-amz-checksum-{algorithm}"
     checksum_cls = _CHECKSUM_CLS.get(algorithm)
     checksum = checksum_cls()
     checksum.update(body)
     expected = response["headers"][header_name]
     if checksum.digest() != base64.b64decode(expected):
         error_msg = (
-            "Expected checksum %s did not match calculated checksum: %s"
-            % (
-                expected,
-                checksum.b64digest(),
-            )
+            f"Expected checksum {expected} did not match calculated "
+            f"checksum: {checksum.b64digest()}"
         )
         raise FlexibleChecksumError(error_msg=error_msg)
     return body

botocore/loaders.py

@@ -101,6 +101,7 @@ information that doesn't quite fit in the original models, but is still needed
 for the sdk. For instance, additional operation parameters might be added here
 which don't represent the actual service api.
 """
+
 import logging
 import os
 

botocore/model.py

@@ -11,6 +11,7 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """Abstractions to interact with service models."""
+
 from collections import defaultdict
 from typing import NamedTuple, Union
 

botocore/paginate.py

@@ -179,7 +179,7 @@ class PaginatorModel:
             single_paginator_config = self._paginator_config[operation_name]
         except KeyError:
             raise ValueError(
-                "Paginator for operation does not exist: %s" % operation_name
+                f"Paginator for operation does not exist: {operation_name}"
             )
         return single_paginator_config
 
@@ -232,7 +232,7 @@ class PageIterator:
     @resume_token.setter
     def resume_token(self, value):
         if not isinstance(value, dict):
-            raise ValueError("Bad starting token: %s" % value)
+            raise ValueError(f"Bad starting token: {value}")
 
         if 'boto_truncate_amount' in value:
             token_keys = sorted(self._input_token + ['boto_truncate_amount'])
@@ -243,7 +243,7 @@ class PageIterator:
         if token_keys == dict_keys:
             self._resume_token = self._token_encoder.encode(value)
         else:
-            raise ValueError("Bad starting token: %s" % value)
+            raise ValueError(f"Bad starting token: {value}")
 
     @property
     def non_aggregate_part(self):
@@ -546,7 +546,7 @@ class PageIterator:
         """
         log.debug(
             "Attempting to fall back to old starting token parser. For "
-            "token: %s" % self._starting_token
+            f"token: {self._starting_token}"
         )
         if self._starting_token is None:
             return None
@@ -577,7 +577,7 @@ class PageIterator:
         len_deprecated_token = len(deprecated_token)
         len_input_token = len(self._input_token)
         if len_deprecated_token > len_input_token:
-            raise ValueError("Bad starting token: %s" % self._starting_token)
+            raise ValueError(f"Bad starting token: {self._starting_token}")
         elif len_deprecated_token < len_input_token:
             log.debug(
                 "Old format starting token does not contain all input "

botocore/parsers.py

@@ -114,6 +114,7 @@ Each call to ``parse()`` returns a dict has this form::
     }
 
 """
+
 import base64
 import http.client
 import json
@@ -315,7 +316,7 @@ class ResponseParser:
         }
 
     def _do_parse(self, response, shape):
-        raise NotImplementedError("%s._do_parse" % self.__class__.__name__)
+        raise NotImplementedError(f"{self.__class__.__name__}._do_parse")
 
     def _do_error_parse(self, response, shape):
         raise NotImplementedError(f"{self.__class__.__name__}._do_error_parse")
@@ -398,7 +399,7 @@ class BaseXMLResponseParser(ResponseParser):
                 elif tag_name == value_location_name:
                     val_name = self._parse_shape(value_shape, single_pair)
                 else:
-                    raise ResponseParserError("Unknown tag: %s" % tag_name)
+                    raise ResponseParserError(f"Unknown tag: {tag_name}")
             parsed[key_name] = val_name
         return parsed
 
@@ -506,9 +507,8 @@ class BaseXMLResponseParser(ResponseParser):
             root = parser.close()
         except XMLParseError as e:
             raise ResponseParserError(
-                "Unable to parse response (%s), "
-                "invalid XML received. Further retries may succeed:\n%s"
-                % (e, xml_string)
+                f"Unable to parse response ({e}), "
+                f"invalid XML received. Further retries may succeed:\n{xml_string}"
             )
         return root
 

botocore/regions.py

@@ -16,6 +16,7 @@ This module implements endpoint resolution, including resolving endpoints for a
 given service and region and resolving the available endpoints for a service
 in a specific AWS partition.
 """
+
 import copy
 import logging
 import re
@@ -261,7 +262,7 @@ class EndpointResolver(BaseEndpointResolver):
         ):
             error_msg = (
                 "Dualstack endpoints are currently not supported"
-                " for %s partition" % partition_name
+                f" for {partition_name} partition"
             )
             raise EndpointVariantError(tags=['dualstack'], error_msg=error_msg)
 
@@ -357,8 +358,7 @@ class EndpointResolver(BaseEndpointResolver):
 
         if endpoint_data.get('deprecated'):
             LOG.warning(
-                'Client is configured with the deprecated endpoint: %s'
-                % (endpoint_name)
+                f'Client is configured with the deprecated endpoint: {endpoint_name}'
             )
 
         service_defaults = service_data.get('defaults', {})
@@ -496,7 +496,7 @@ class EndpointRulesetResolver:
             operation_model, call_args, request_context
         )
         LOG.debug(
-            'Calling endpoint provider with parameters: %s' % provider_params
+            f'Calling endpoint provider with parameters: {provider_params}'
         )
         try:
             provider_result = self._provider.resolve_endpoint(
@@ -510,7 +510,7 @@ class EndpointRulesetResolver:
                 raise
             else:
                 raise botocore_exception from ex
-        LOG.debug('Endpoint provider result: %s' % provider_result.url)
+        LOG.debug(f'Endpoint provider result: {provider_result.url}')
 
         # The endpoint provider does not support non-secure transport.
         if not self._use_ssl and provider_result.url.startswith('https://'):
@@ -633,7 +633,7 @@ class EndpointRulesetResolver:
         customized_builtins = copy.copy(self._builtins)
         # Handlers are expected to modify the builtins dict in place.
         self._event_emitter.emit(
-            'before-endpoint-resolution.%s' % service_id,
+            f'before-endpoint-resolution.{service_id}',
             builtins=customized_builtins,
             model=operation_model,
             params=call_args,

botocore/retries/bucket.py

@@ -1,4 +1,5 @@
 """This module implements token buckets used for client side throttling."""
+
 import threading
 import time
 

botocore/retries/quota.py

@@ -1,7 +1,5 @@
-"""Retry quota implementation.
+"""Retry quota implementation."""
 
-
-"""
 import threading
 
 

botocore/retries/special.py

@@ -5,6 +5,7 @@ retry handler.  They don't make sense as part of the standard mode retry
 module.  Ideally we should be able to remove this module.
 
 """
+
 import logging
 from binascii import crc32
 

botocore/retries/standard.py

@@ -23,6 +23,7 @@ This allows us to define an API that has minimal coupling to the event
 based API used by botocore.
 
 """
+
 import logging
 import random
 
@@ -57,9 +58,9 @@ def register_retry_handler(client, max_attempts=DEFAULT_MAX_ATTEMPTS):
         retry_quota=retry_quota,
     )
 
-    unique_id = 'retry-config-%s' % service_event_name
+    unique_id = f'retry-config-{service_event_name}'
     client.meta.events.register(
-        'needs-retry.%s' % service_event_name,
+        f'needs-retry.{service_event_name}',
         handler.needs_retry,
         unique_id=unique_id,
     )

botocore/retryhandler.py

@@ -288,9 +288,9 @@ class MaxAttemptsDecorator(BaseChecker):
             if attempt_number >= self._max_attempts:
                 # explicitly set MaxAttemptsReached
                 if response is not None and 'ResponseMetadata' in response[1]:
-                    response[1]['ResponseMetadata'][
-                        'MaxAttemptsReached'
-                    ] = True
+                    response[1]['ResponseMetadata']['MaxAttemptsReached'] = (
+                        True
+                    )
                 logger.debug(
                     "Reached the maximum number of retry attempts: %s",
                     attempt_number,

botocore/serialize.py

@@ -37,6 +37,7 @@ The input to the serializers should be text (str/unicode), not bytes,
 with the exception of blob types.  Those are assumed to be binary,
 and if a str/unicode type is passed in, it will be encoded as utf-8.
 """
+
 import base64
 import calendar
 import datetime
@@ -277,7 +278,7 @@ class QuerySerializer(Serializer):
         if self._is_shape_flattened(shape):
             full_prefix = prefix
         else:
-            full_prefix = '%s.entry' % prefix
+            full_prefix = f'{prefix}.entry'
         template = full_prefix + '.{i}.{suffix}'
         key_shape = shape.key
         value_shape = shape.value
@@ -356,7 +357,7 @@ class JSONSerializer(Serializer):
         )
         serialized['headers'] = {
             'X-Amz-Target': target,
-            'Content-Type': 'application/x-amz-json-%s' % json_version,
+            'Content-Type': f'application/x-amz-json-{json_version}',
         }
         body = self.MAP_TYPE()
         input_shape = operation_model.input_shape
@@ -373,7 +374,7 @@ class JSONSerializer(Serializer):
     def _serialize(self, serialized, value, shape, key=None):
         method = getattr(
             self,
-            '_serialize_type_%s' % shape.type_name,
+            f'_serialize_type_{shape.type_name}',
             self._default_serialize,
         )
         method(serialized, value, shape, key)
@@ -713,7 +714,7 @@ class RestXMLSerializer(BaseRestSerializer):
     def _serialize(self, shape, params, xmlnode, name):
         method = getattr(
             self,
-            '_serialize_type_%s' % shape.type_name,
+            f'_serialize_type_{shape.type_name}',
             self._default_serialize,
         )
         method(xmlnode, params, shape, name)
@@ -725,7 +726,7 @@ class RestXMLSerializer(BaseRestSerializer):
             namespace_metadata = shape.serialization['xmlNamespace']
             attribute_name = 'xmlns'
             if namespace_metadata.get('prefix'):
-                attribute_name += ':%s' % namespace_metadata['prefix']
+                attribute_name += f":{namespace_metadata['prefix']}"
             structure_node.attrib[attribute_name] = namespace_metadata['uri']
         for key, value in params.items():
             member_shape = shape.members[key]

botocore/session.py

@@ -557,11 +557,11 @@ class Session:
             f'{platform.system()}/{platform.release()}'
         )
         if HAS_CRT:
-            base += ' awscrt/%s' % self._get_crt_version()
+            base += f' awscrt/{self._get_crt_version()}'
         if os.environ.get('AWS_EXECUTION_ENV') is not None:
-            base += ' exec-env/%s' % os.environ.get('AWS_EXECUTION_ENV')
+            base += ' exec-env/{}'.format(os.environ.get('AWS_EXECUTION_ENV'))
         if self.user_agent_extra:
-            base += ' %s' % self.user_agent_extra
+            base += f' {self.user_agent_extra}'
 
         return base
 
@@ -615,7 +615,7 @@ class Session:
         )
         service_id = EVENT_ALIASES.get(service_name, service_name)
         self._events.emit(
-            'service-data-loaded.%s' % service_id,
+            f'service-data-loaded.{service_id}',
             service_data=service_data,
             service_name=service_name,
             session=self,
@@ -803,9 +803,9 @@ class Session:
         except ValueError:
             if name in ['endpoint_resolver', 'exceptions_factory']:
                 warnings.warn(
-                    'Fetching the %s component with the get_component() '
+                    f'Fetching the {name} component with the get_component() '
                     'method is deprecated as the component has always been '
-                    'considered an internal interface of botocore' % name,
+                    'considered an internal interface of botocore',
                     DeprecationWarning,
                 )
                 return self._internal_components.get_component(name)
@@ -1153,7 +1153,7 @@ class ComponentLocator:
         try:
             return self._components[name]
         except KeyError:
-            raise ValueError("Unknown component: %s" % name)
+            raise ValueError(f"Unknown component: {name}")
 
     def register_component(self, name, component):
         self._components[name] = component

botocore/signers.py

@@ -152,9 +152,7 @@ class RequestSigner:
 
         # Allow mutating request before signing
         self._event_emitter.emit(
-            'before-sign.{}.{}'.format(
-                self._service_id.hyphenize(), operation_name
-            ),
+            f'before-sign.{self._service_id.hyphenize()}.{operation_name}',
             request=request,
             signing_name=signing_name,
             region_name=self._region_name,
@@ -231,9 +229,7 @@ class RequestSigner:
             signature_version += suffix
 
         handler, response = self._event_emitter.emit_until_response(
-            'choose-signer.{}.{}'.format(
-                self._service_id.hyphenize(), operation_name
-            ),
+            f'choose-signer.{self._service_id.hyphenize()}.{operation_name}',
             signing_name=signing_name,
             region_name=region_name,
             signature_version=signature_version,
@@ -428,9 +424,9 @@ class CloudFrontSigner:
         if isinstance(policy, str):
             policy = policy.encode('utf8')
         if date_less_than is not None:
-            params = ['Expires=%s' % int(datetime2timestamp(date_less_than))]
+            params = [f'Expires={int(datetime2timestamp(date_less_than))}']
         else:
-            params = ['Policy=%s' % self._url_b64encode(policy).decode('utf8')]
+            params = [f"Policy={self._url_b64encode(policy).decode('utf8')}"]
         signature = self.rsa_signer(policy)
         params.extend(
             [

botocore/stub.py

@@ -239,8 +239,8 @@ class Stubber:
     def _add_response(self, method, service_response, expected_params):
         if not hasattr(self.client, method):
             raise ValueError(
-                "Client %s does not have method: %s"
-                % (self.client.meta.service_model.service_name, method)
+                f"Client {self.client.meta.service_model.service_name} "
+                f"does not have method: {method}"
             )
 
         # Create a successful http response
@@ -383,16 +383,20 @@ class Stubber:
             if param not in params or expected_params[param] != params[param]:
                 raise StubAssertionError(
                     operation_name=model.name,
-                    reason='Expected parameters:\n%s,\nbut received:\n%s'
-                    % (pformat(expected_params), pformat(params)),
+                    reason=(
+                        f'Expected parameters:\n{pformat(expected_params)},\n'
+                        f'but received:\n{pformat(params)}'
+                    ),
                 )
 
         # Ensure there are no extra params hanging around
         if sorted(expected_params.keys()) != sorted(params.keys()):
             raise StubAssertionError(
                 operation_name=model.name,
-                reason='Expected parameters:\n%s,\nbut received:\n%s'
-                % (pformat(expected_params), pformat(params)),
+                reason=(
+                    f'Expected parameters:\n{pformat(expected_params)},\n'
+                    f'but received:\n{pformat(params)}'
+                ),
             )
 
     def _should_not_stub(self, context):

botocore/useragent.py

@@ -22,6 +22,7 @@ configuration options:
 * The ``user_agent_extra`` field in the :py:class:`botocore.config.Config`.
 
 """
+
 import os
 import platform
 from copy import copy