botocore 1.37.24__tar.gz → 1.37.25__tar.gz

{botocore-1.37.24/botocore.egg-info → botocore-1.37.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: botocore
-Version: 1.37.24
+Version: 1.37.25
 Summary: Low-level, data-driven core of boto 3.
 Home-page: https://github.com/boto/botocore
 Author: Amazon Web Services

{botocore-1.37.24 → botocore-1.37.25}/botocore/__init__.py

@@ -16,7 +16,7 @@ import logging
 import os
 import re
 
-__version__ = '1.37.24'
+__version__ = '1.37.25'
 
 
 class NullHandler(logging.Handler):

{botocore-1.37.24 → botocore-1.37.25}/botocore/data/cleanrooms/2022-02-17/service-2.json

@@ -9709,6 +9709,10 @@
         "description":{
           "shape":"CollaborationDescription",
           "documentation":"<p>A description of the collaboration.</p>"
+        },
+        "analyticsEngine":{
+          "shape":"AnalyticsEngine",
+          "documentation":"<p>The analytics engine.</p>"
         }
       }
     },

{botocore-1.37.24 → botocore-1.37.25}/botocore/data/endpoints.json

@@ -36428,10 +36428,33 @@
       },
       "glacier" : {
         "endpoints" : {
+          "fips-us-iso-east-1" : {
+            "credentialScope" : {
+              "region" : "us-iso-east-1"
+            },
+            "deprecated" : true,
+            "hostname" : "glacier-fips.us-iso-east-1.c2s.ic.gov"
+          },
+          "fips-us-iso-west-1" : {
+            "credentialScope" : {
+              "region" : "us-iso-west-1"
+            },
+            "deprecated" : true,
+            "hostname" : "glacier-fips.us-iso-west-1.c2s.ic.gov"
+          },
           "us-iso-east-1" : {
-            "protocols" : [ "http", "https" ]
+            "protocols" : [ "http", "https" ],
+            "variants" : [ {
+              "hostname" : "glacier-fips.us-iso-east-1.c2s.ic.gov",
+              "tags" : [ "fips" ]
+            } ]
           },
-          "us-iso-west-1" : { }
+          "us-iso-west-1" : {
+            "variants" : [ {
+              "hostname" : "glacier-fips.us-iso-west-1.c2s.ic.gov",
+              "tags" : [ "fips" ]
+            } ]
+          }
         }
       },
       "glue" : {
@@ -37411,7 +37434,19 @@
       },
       "glacier" : {
         "endpoints" : {
-          "us-isob-east-1" : { }
+          "fips-us-isob-east-1" : {
+            "credentialScope" : {
+              "region" : "us-isob-east-1"
+            },
+            "deprecated" : true,
+            "hostname" : "glacier-fips.us-isob-east-1.sc2s.sgov.gov"
+          },
+          "us-isob-east-1" : {
+            "variants" : [ {
+              "hostname" : "glacier-fips.us-isob-east-1.sc2s.sgov.gov",
+              "tags" : [ "fips" ]
+            } ]
+          }
         }
       },
       "health" : {

{botocore-1.37.24 → botocore-1.37.25}/botocore/data/sagemaker/2017-07-24/service-2.json

@@ -11197,6 +11197,10 @@
         "OnStart":{
           "shape":"NotebookInstanceLifecycleConfigList",
           "documentation":"<p>A shell script that runs every time you start a notebook instance, including when you create the notebook instance. The shell script must be a base64-encoded string.</p>"
+        },
+        "Tags":{
+          "shape":"TagList",
+          "documentation":"<p>An array of key-value pairs. You can use tags to categorize your Amazon Web Services resources in different ways, for example, by purpose, owner, or environment. For more information, see <a href=\"https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html\">Tagging Amazon Web Services Resources</a>.</p>"
         }
       }
     },

{botocore-1.37.24 → botocore-1.37.25}/botocore/serialize.py

@@ -182,6 +182,8 @@ class Serializer:
             return None
 
         host_prefix_expression = operation_endpoint['hostPrefix']
+        if operation_model.input_shape is None:
+            return host_prefix_expression
         input_members = operation_model.input_shape.members
         host_labels = [
             member
@@ -205,6 +207,18 @@ class Serializer:
             )
         return host_prefix_expression.format(**format_kwargs)
 
+    def _is_shape_flattened(self, shape):
+        return shape.serialization.get('flattened')
+
+    def _handle_float(self, value):
+        if value == float("Infinity"):
+            value = "Infinity"
+        elif value == float("-Infinity"):
+            value = "-Infinity"
+        elif math.isnan(value):
+            value = "NaN"
+        return value
+
 
 class QuerySerializer(Serializer):
     TIMESTAMP_FORMAT = 'iso8601'
@@ -310,8 +324,11 @@ class QuerySerializer(Serializer):
     def _default_serialize(self, serialized, value, shape, prefix=''):
         serialized[prefix] = value
 
-    def _is_shape_flattened(self, shape):
-        return shape.serialization.get('flattened')
+    def _serialize_type_float(self, serialized, value, shape, prefix=''):
+        serialized[prefix] = self._handle_float(value)
+
+    def _serialize_type_double(self, serialized, value, shape, prefix=''):
+        self._serialize_type_float(serialized, value, shape, prefix)
 
 
 class EC2Serializer(QuerySerializer):
@@ -326,7 +343,7 @@ class EC2Serializer(QuerySerializer):
 
     def _get_serialized_name(self, shape, default_name):
         # Returns the serialized name for the shape if it exists.
-        # Otherwise it will return the passed in default_name.
+        # Otherwise it will return the passed in capitalized default_name.
         if 'queryName' in shape.serialization:
             return shape.serialization['queryName']
         elif 'name' in shape.serialization:
@@ -432,6 +449,12 @@ class JSONSerializer(Serializer):
     def _serialize_type_blob(self, serialized, value, shape, key):
         serialized[key] = self._get_base64(value)
 
+    def _serialize_type_float(self, serialized, value, shape, prefix=''):
+        serialized[prefix] = self._handle_float(value)
+
+    def _serialize_type_double(self, serialized, value, shape, prefix=''):
+        self._serialize_type_float(serialized, value, shape, prefix)
+
 
 class CBORSerializer(Serializer):
     UNSIGNED_INT_MAJOR_TYPE = 0
@@ -699,6 +722,11 @@ class BaseRestSerializer(Serializer):
             'method', self.DEFAULT_METHOD
         )
         shape = operation_model.input_shape
+
+        host_prefix = self._expand_host_prefix(parameters, operation_model)
+        if host_prefix is not None:
+            serialized['host_prefix'] = host_prefix
+
         if shape is None:
             serialized['url_path'] = operation_model.http['requestUri']
             return serialized
@@ -746,10 +774,6 @@ class BaseRestSerializer(Serializer):
         )
         self._serialize_content_type(serialized, shape, shape_members)
 
-        host_prefix = self._expand_host_prefix(parameters, operation_model)
-        if host_prefix is not None:
-            serialized['host_prefix'] = host_prefix
-
         return serialized
 
     def _render_uri_template(self, uri_template, params):
@@ -844,30 +868,32 @@ class BaseRestSerializer(Serializer):
         location = member.serialization.get('location')
         key_name = member.serialization.get('name', param_name)
         if location == 'uri':
-            partitioned['uri_path_kwargs'][key_name] = param_value
+            uri_path_value = self._get_uri_and_query_string_value(
+                param_value, member
+            )
+            partitioned['uri_path_kwargs'][key_name] = uri_path_value
         elif location == 'querystring':
             if isinstance(param_value, dict):
                 partitioned['query_string_kwargs'].update(param_value)
-            elif isinstance(param_value, bool):
-                bool_str = str(param_value).lower()
-                partitioned['query_string_kwargs'][key_name] = bool_str
-            elif member.type_name == 'timestamp':
-                timestamp_format = member.serialization.get(
-                    'timestampFormat', self.QUERY_STRING_TIMESTAMP_FORMAT
-                )
-                timestamp = self._convert_timestamp_to_str(
-                    param_value, timestamp_format
-                )
-                partitioned['query_string_kwargs'][key_name] = timestamp
+            elif member.type_name == 'list':
+                new_param = [
+                    self._get_uri_and_query_string_value(value, member.member)
+                    for value in param_value
+                ]
+                partitioned['query_string_kwargs'][key_name] = new_param
             else:
-                partitioned['query_string_kwargs'][key_name] = param_value
+                new_param = self._get_uri_and_query_string_value(
+                    param_value, member
+                )
+                partitioned['query_string_kwargs'][key_name] = new_param
         elif location == 'header':
             shape = shape_members[param_name]
             if not param_value and shape.type_name == 'list':
                 # Empty lists should not be set on the headers
                 return
-            value = self._convert_header_value(shape, param_value)
-            partitioned['headers'][key_name] = str(value)
+            partitioned['headers'][key_name] = self._convert_header_value(
+                shape, param_value
+            )
         elif location == 'headers':
             # 'headers' is a bit of an oddball.  The ``key_name``
             # is actually really a prefix for the header names:
@@ -882,6 +908,20 @@ class BaseRestSerializer(Serializer):
         else:
             partitioned['body_kwargs'][param_name] = param_value
 
+    def _get_uri_and_query_string_value(self, param_value, member):
+        if member.type_name == 'boolean':
+            return str(param_value).lower()
+        elif member.type_name == 'timestamp':
+            timestamp_format = member.serialization.get(
+                'timestampFormat', self.QUERY_STRING_TIMESTAMP_FORMAT
+            )
+            return self._convert_timestamp_to_str(
+                param_value, timestamp_format
+            )
+        elif member.type_name in ['float', 'double']:
+            return str(self._handle_float(param_value))
+        return param_value
+
     def _do_serialize_header_map(self, header_prefix, headers, user_input):
         for key, val in user_input.items():
             full_key = header_prefix + key
@@ -897,18 +937,39 @@ class BaseRestSerializer(Serializer):
             timestamp_format = shape.serialization.get(
                 'timestampFormat', self.HEADER_TIMESTAMP_FORMAT
             )
-            return self._convert_timestamp_to_str(timestamp, timestamp_format)
+            return str(
+                self._convert_timestamp_to_str(timestamp, timestamp_format)
+            )
         elif shape.type_name == 'list':
-            converted_value = [
-                self._convert_header_value(shape.member, v)
-                for v in value
-                if v is not None
-            ]
+            if shape.member.type_name == "string":
+                converted_value = [
+                    self._escape_header_list_string(v)
+                    for v in value
+                    if v is not None
+                ]
+            else:
+                converted_value = [
+                    self._convert_header_value(shape.member, v)
+                    for v in value
+                    if v is not None
+                ]
             return ",".join(converted_value)
         elif is_json_value_header(shape):
             # Serialize with no spaces after separators to save space in
             # the header.
             return self._get_base64(json.dumps(value, separators=(',', ':')))
+        elif shape.type_name == 'boolean':
+            return str(value).lower()
+        elif shape.type_name in ['float', 'double']:
+            return str(self._handle_float(value))
+        else:
+            return str(value)
+
+    def _escape_header_list_string(self, value):
+        # Escapes a header list string by wrapping it in double quotes if it contains
+        # a comma or a double quote, and escapes any internal double quotes.
+        if '"' in value or ',' in value:
+            return '"' + value.replace('"', '\\"') + '"'
         else:
             return value
 
@@ -1005,12 +1066,7 @@ class RestXMLSerializer(BaseRestSerializer):
     def _serialize_type_structure(self, xmlnode, params, shape, name):
         structure_node = ElementTree.SubElement(xmlnode, name)
 
-        if 'xmlNamespace' in shape.serialization:
-            namespace_metadata = shape.serialization['xmlNamespace']
-            attribute_name = 'xmlns'
-            if namespace_metadata.get('prefix'):
-                attribute_name += f":{namespace_metadata['prefix']}"
-            structure_node.attrib[attribute_name] = namespace_metadata['uri']
+        self._add_xml_namespace(shape, structure_node)
         for key, value in params.items():
             member_shape = shape.members[key]
             member_name = member_shape.serialization.get('name', key)
@@ -1036,6 +1092,7 @@ class RestXMLSerializer(BaseRestSerializer):
         else:
             element_name = member_shape.serialization.get('name', 'member')
             list_node = ElementTree.SubElement(xmlnode, name)
+        self._add_xml_namespace(shape, list_node)
         for item in params:
             self._serialize(member_shape, item, list_node, element_name)
 
@@ -1048,16 +1105,22 @@ class RestXMLSerializer(BaseRestSerializer):
         #       <value>val1</value>
         #     </entry>
         #  </MyMap>
-        node = ElementTree.SubElement(xmlnode, name)
-        # TODO: handle flattened maps.
+        if not self._is_shape_flattened(shape):
+            node = ElementTree.SubElement(xmlnode, name)
+            self._add_xml_namespace(shape, node)
+
         for key, value in params.items():
-            entry_node = ElementTree.SubElement(node, 'entry')
+            sub_node = (
+                ElementTree.SubElement(xmlnode, name)
+                if self._is_shape_flattened(shape)
+                else ElementTree.SubElement(node, 'entry')
+            )
             key_name = self._get_serialized_name(shape.key, default_name='key')
             val_name = self._get_serialized_name(
                 shape.value, default_name='value'
             )
-            self._serialize(shape.key, key, entry_node, key_name)
-            self._serialize(shape.value, value, entry_node, val_name)
+            self._serialize(shape.key, key, sub_node, key_name)
+            self._serialize(shape.value, value, sub_node, val_name)
 
     def _serialize_type_boolean(self, xmlnode, params, shape, name):
         # For scalar types, the 'params' attr is actually just a scalar
@@ -1069,20 +1132,47 @@ class RestXMLSerializer(BaseRestSerializer):
         else:
             str_value = 'false'
         node.text = str_value
+        self._add_xml_namespace(shape, node)
 
     def _serialize_type_blob(self, xmlnode, params, shape, name):
         node = ElementTree.SubElement(xmlnode, name)
         node.text = self._get_base64(params)
+        self._add_xml_namespace(shape, node)
 
     def _serialize_type_timestamp(self, xmlnode, params, shape, name):
         node = ElementTree.SubElement(xmlnode, name)
-        node.text = self._convert_timestamp_to_str(
-            params, shape.serialization.get('timestampFormat')
+        node.text = str(
+            self._convert_timestamp_to_str(
+                params, shape.serialization.get('timestampFormat')
+            )
         )
+        self._add_xml_namespace(shape, node)
+
+    def _serialize_type_float(self, xmlnode, params, shape, name):
+        node = ElementTree.SubElement(xmlnode, name)
+        node.text = str(self._handle_float(params))
+        self._add_xml_namespace(shape, node)
+
+    def _serialize_type_double(self, xmlnode, params, shape, name):
+        self._serialize_type_float(xmlnode, params, shape, name)
 
     def _default_serialize(self, xmlnode, params, shape, name):
         node = ElementTree.SubElement(xmlnode, name)
         node.text = str(params)
+        self._add_xml_namespace(shape, node)
+
+    def _add_xml_namespace(self, shape, structure_node):
+        if 'xmlNamespace' in shape.serialization:
+            namespace_metadata = shape.serialization['xmlNamespace']
+            attribute_name = 'xmlns'
+            if isinstance(namespace_metadata, dict):
+                if namespace_metadata.get('prefix'):
+                    attribute_name += f":{namespace_metadata['prefix']}"
+                structure_node.attrib[attribute_name] = namespace_metadata[
+                    'uri'
+                ]
+            elif isinstance(namespace_metadata, str):
+                structure_node.attrib[attribute_name] = namespace_metadata
 
 
 class RpcV2CBORSerializer(BaseRpcV2Serializer, CBORSerializer):

{botocore-1.37.24 → botocore-1.37.25/botocore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: botocore
-Version: 1.37.24
+Version: 1.37.25
 Summary: Low-level, data-driven core of boto 3.
 Home-page: https://github.com/boto/botocore
 Author: Amazon Web Services

{botocore-1.37.24 → botocore-1.37.25}/botocore.egg-info/SOURCES.txt

@@ -2778,10 +2778,16 @@ tests/unit/docs/bcdoc/test_style.py
 tests/unit/protocols/protocol-tests-ignore-list.json
 tests/unit/protocols/input/ec2.json
 tests/unit/protocols/input/json.json
+tests/unit/protocols/input/json_1_0.json
 tests/unit/protocols/input/query.json
 tests/unit/protocols/input/rest-json.json
 tests/unit/protocols/input/rest-xml.json
 tests/unit/protocols/input/smithy-rpc-v2-cbor.json
+tests/unit/protocols/legacy/input/ec2.json
+tests/unit/protocols/legacy/input/json.json
+tests/unit/protocols/legacy/input/query.json
+tests/unit/protocols/legacy/input/rest-json.json
+tests/unit/protocols/legacy/input/rest-xml.json
 tests/unit/protocols/legacy/output/ec2.json
 tests/unit/protocols/legacy/output/json.json
 tests/unit/protocols/legacy/output/query.json

{botocore-1.37.24 → botocore-1.37.25}/docs/source/conf.py

@@ -59,7 +59,7 @@ copyright = f'{current_year}, Amazon Web Services, Inc'
 # The short X.Y version.
 version = '1.37.'
 # The full version, including alpha/beta/rc tags.
-release = '1.37.24'
+release = '1.37.25'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.