Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/botocore/serialize.py: 23%

1# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved. 

2# 

3# Licensed under the Apache License, Version 2.0 (the "License"). You 

4# may not use this file except in compliance with the License. A copy of 

5# the License is located at 

6# 

7# http://aws.amazon.com/apache2.0/ 

8# 

9# or in the "license" file accompanying this file. This file is 

10# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 

11# ANY KIND, either express or implied. See the License for the specific 

12# language governing permissions and limitations under the License. 

13"""Protocol input serializes. 

14 

15This module contains classes that implement input serialization 

16for the various AWS protocol types. 

17 

18These classes essentially take user input, a model object that 

19represents what the expected input should look like, and it returns 

20a dictionary that contains the various parts of a request. A few 

21high level design decisions: 

22 

23 

24* Each protocol type maps to a separate class, all inherit from 

25 ``Serializer``. 

26* The return value for ``serialize_to_request`` (the main entry 

27 point) returns a dictionary that represents a request. This 

28 will have keys like ``url_path``, ``query_string``, etc. This 

29 is done so that it's a) easy to test and b) not tied to a 

30 particular HTTP library. See the ``serialize_to_request`` docstring 

31 for more details. 

32 

33Unicode 

34------- 

35 

36The input to the serializers should be text (str/unicode), not bytes, 

37with the exception of blob types. Those are assumed to be binary, 

38and if a str/unicode type is passed in, it will be encoded as utf-8. 

39""" 

40 

41import base64 

42import calendar 

43import datetime 

44import decimal 

45import json 

46import math 

47import re 

48import struct 

49from xml.etree import ElementTree 

50 

51from botocore import validate 

52from botocore.compat import formatdate 

53from botocore.exceptions import ParamValidationError 

54from botocore.useragent import register_feature_id 

55from botocore.utils import ( 

56 has_header, 

57 is_json_value_header, 

58 parse_to_aware_datetime, 

59 percent_encode, 

60) 

61 

62# From the spec, the default timestamp format if not specified is iso8601. 

63DEFAULT_TIMESTAMP_FORMAT = 'iso8601' 

64ISO8601 = '%Y-%m-%dT%H:%M:%SZ' 

65# Same as ISO8601, but with microsecond precision. 

66ISO8601_MICRO = '%Y-%m-%dT%H:%M:%S.%fZ' 

67HOST_PREFIX_RE = re.compile(r"^[A-Za-z0-9\.\-]+$") 

68 

69TIMESTAMP_PRECISION_DEFAULT = 'default' 

70TIMESTAMP_PRECISION_MILLISECOND = 'millisecond' 

71TIMESTAMP_PRECISION_OPTIONS = ( 

72 TIMESTAMP_PRECISION_DEFAULT, 

73 TIMESTAMP_PRECISION_MILLISECOND, 

74) 

75 

76 

77def create_serializer( 

78 protocol_name, 

79 include_validation=True, 

80 timestamp_precision=TIMESTAMP_PRECISION_DEFAULT, 

81): 

82 """Create a serializer for the given protocol. 

83 :param protocol_name: The protocol name to create a serializer for. 

84 :type protocol_name: str 

85 :param include_validation: Whether to include parameter validation. 

86 :type include_validation: bool 

87 :param timestamp_precision: Timestamp precision level. 

88 - 'default': Microseconds for ISO timestamps, seconds for Unix and RFC 

89 - 'millisecond': Millisecond precision (ISO/Unix), seconds for RFC 

90 :type timestamp_precision: str 

91 :return: A serializer instance for the given protocol. 

92 """ 

93 # TODO: Unknown protocols. 

94 serializer = SERIALIZERS[protocol_name]( 

95 timestamp_precision=timestamp_precision 

96 ) 

97 if include_validation: 

98 validator = validate.ParamValidator() 

99 serializer = validate.ParamValidationDecorator(validator, serializer) 

100 return serializer 

101 

102 

103class Serializer: 

104 DEFAULT_METHOD = 'POST' 

105 # Clients can change this to a different MutableMapping 

106 # (i.e OrderedDict) if they want. This is used in the 

107 # compliance test to match the hash ordering used in the 

108 # tests. 

109 MAP_TYPE = dict 

110 DEFAULT_ENCODING = 'utf-8' 

111 

112 def __init__(self, timestamp_precision=TIMESTAMP_PRECISION_DEFAULT): 

113 if timestamp_precision not in TIMESTAMP_PRECISION_OPTIONS: 

114 raise ValueError( 

115 f"Invalid timestamp precision found while creating serializer: {timestamp_precision}" 

116 ) 

117 self._timestamp_precision = timestamp_precision 

118 

119 def serialize_to_request(self, parameters, operation_model): 

120 """Serialize parameters into an HTTP request. 

121 

122 This method takes user provided parameters and a shape 

123 model and serializes the parameters to an HTTP request. 

124 More specifically, this method returns information about 

125 parts of the HTTP request, it does not enforce a particular 

126 interface or standard for an HTTP request. It instead returns 

127 a dictionary of: 

128 

129 * 'url_path' 

130 * 'host_prefix' 

131 * 'query_string' 

132 * 'headers' 

133 * 'body' 

134 * 'method' 

135 

136 It is then up to consumers to decide how to map this to a Request 

137 object of their HTTP library of choice. Below is an example 

138 return value:: 

139 

140 {'body': {'Action': 'OperationName', 

141 'Bar': 'val2', 

142 'Foo': 'val1', 

143 'Version': '2014-01-01'}, 

144 'headers': {}, 

145 'method': 'POST', 

146 'query_string': '', 

147 'host_prefix': 'value.', 

148 'url_path': '/'} 

149 

150 :param parameters: The dictionary input parameters for the 

151 operation (i.e the user input). 

152 :param operation_model: The OperationModel object that describes 

153 the operation. 

154 """ 

155 raise NotImplementedError("serialize_to_request") 

156 

157 def _create_default_request(self): 

158 # Creates a boilerplate default request dict that subclasses 

159 # can use as a starting point. 

160 serialized = { 

161 'url_path': '/', 

162 'query_string': '', 

163 'method': self.DEFAULT_METHOD, 

164 'headers': {}, 

165 # An empty body is represented as an empty byte string. 

166 'body': b'', 

167 } 

168 return serialized 

169 

170 # Some extra utility methods subclasses can use. 

171 

172 def _timestamp_iso8601(self, value): 

173 """Return ISO8601 timestamp with precision based on timestamp_precision.""" 

174 # Smithy's standard is milliseconds, so we truncate the timestamp if the millisecond flag is set to true 

175 if self._timestamp_precision == TIMESTAMP_PRECISION_MILLISECOND: 

176 milliseconds = value.microsecond // 1000 

177 return ( 

178 value.strftime('%Y-%m-%dT%H:%M:%S') + f'.{milliseconds:03d}Z' 

179 ) 

180 else: 

181 # Otherwise we continue supporting microseconds in iso8601 for legacy reasons 

182 if value.microsecond > 0: 

183 timestamp_format = ISO8601_MICRO 

184 else: 

185 timestamp_format = ISO8601 

186 return value.strftime(timestamp_format) 

187 

188 def _timestamp_unixtimestamp(self, value): 

189 """Return unix timestamp with precision based on timestamp_precision.""" 

190 # As of the addition of the precision flag, we support millisecond precision here as well 

191 if self._timestamp_precision == TIMESTAMP_PRECISION_MILLISECOND: 

192 base_timestamp = calendar.timegm(value.timetuple()) 

193 milliseconds = (value.microsecond // 1000) / 1000.0 

194 return base_timestamp + milliseconds 

195 else: 

196 return int(calendar.timegm(value.timetuple())) 

197 

198 def _timestamp_rfc822(self, value): 

199 """Return RFC822 timestamp (always second precision - RFC doesn't support sub-second).""" 

200 # RFC 2822 doesn't support sub-second precision, so always use second precision format 

201 if isinstance(value, datetime.datetime): 

202 value = int(calendar.timegm(value.timetuple())) 

203 return formatdate(value, usegmt=True) 

204 

205 def _convert_timestamp_to_str(self, value, timestamp_format=None): 

206 if timestamp_format is None: 

207 timestamp_format = self.TIMESTAMP_FORMAT 

208 timestamp_format = timestamp_format.lower() 

209 datetime_obj = parse_to_aware_datetime(value) 

210 converter = getattr(self, f'_timestamp_{timestamp_format}') 

211 final_value = converter(datetime_obj) 

212 return final_value 

213 

214 def _get_serialized_name(self, shape, default_name): 

215 # Returns the serialized name for the shape if it exists. 

216 # Otherwise it will return the passed in default_name. 

217 return shape.serialization.get('name', default_name) 

218 

219 def _get_base64(self, value): 

220 # Returns the base64-encoded version of value, handling 

221 # both strings and bytes. The returned value is a string 

222 # via the default encoding. 

223 if isinstance(value, str): 

224 value = value.encode(self.DEFAULT_ENCODING) 

225 return base64.b64encode(value).strip().decode(self.DEFAULT_ENCODING) 

226 

227 def _expand_host_prefix(self, parameters, operation_model): 

228 operation_endpoint = operation_model.endpoint 

229 if ( 

230 operation_endpoint is None 

231 or 'hostPrefix' not in operation_endpoint 

232 ): 

233 return None 

234 

235 host_prefix_expression = operation_endpoint['hostPrefix'] 

236 if operation_model.input_shape is None: 

237 return host_prefix_expression 

238 input_members = operation_model.input_shape.members 

239 host_labels = [ 

240 member 

241 for member, shape in input_members.items() 

242 if shape.serialization.get('hostLabel') 

243 ] 

244 format_kwargs = {} 

245 bad_labels = [] 

246 for name in host_labels: 

247 param = parameters[name] 

248 if not HOST_PREFIX_RE.match(param): 

249 bad_labels.append(name) 

250 format_kwargs[name] = param 

251 if bad_labels: 

252 raise ParamValidationError( 

253 report=( 

254 f"Invalid value for parameter(s): {', '.join(bad_labels)}. " 

255 "Must contain only alphanumeric characters, hyphen, " 

256 "or period." 

257 ) 

258 ) 

259 return host_prefix_expression.format(**format_kwargs) 

260 

261 def _is_shape_flattened(self, shape): 

262 return shape.serialization.get('flattened') 

263 

264 def _handle_float(self, value): 

265 if value == float("Infinity"): 

266 value = "Infinity" 

267 elif value == float("-Infinity"): 

268 value = "-Infinity" 

269 elif math.isnan(value): 

270 value = "NaN" 

271 return value 

272 

273 def _handle_query_compatible_trait(self, operation_model, serialized): 

274 if operation_model.service_model.is_query_compatible: 

275 serialized['headers']['x-amzn-query-mode'] = 'true' 

276 

277 

278class QuerySerializer(Serializer): 

279 TIMESTAMP_FORMAT = 'iso8601' 

280 

281 def serialize_to_request(self, parameters, operation_model): 

282 shape = operation_model.input_shape 

283 serialized = self._create_default_request() 

284 serialized['method'] = operation_model.http.get( 

285 'method', self.DEFAULT_METHOD 

286 ) 

287 serialized['headers'] = { 

288 'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8' 

289 } 

290 # The query serializer only deals with body params so 

291 # that's what we hand off the _serialize_* methods. 

292 body_params = self.MAP_TYPE() 

293 body_params['Action'] = operation_model.name 

294 body_params['Version'] = operation_model.metadata['apiVersion'] 

295 if shape is not None: 

296 self._serialize(body_params, parameters, shape) 

297 serialized['body'] = body_params 

298 

299 host_prefix = self._expand_host_prefix(parameters, operation_model) 

300 if host_prefix is not None: 

301 serialized['host_prefix'] = host_prefix 

302 

303 return serialized 

304 

305 def _serialize(self, serialized, value, shape, prefix=''): 

306 # serialized: The dict that is incrementally added to with the 

307 # final serialized parameters. 

308 # value: The current user input value. 

309 # shape: The shape object that describes the structure of the 

310 # input. 

311 # prefix: The incrementally built up prefix for the serialized 

312 # key (i.e Foo.bar.members.1). 

313 method = getattr( 

314 self, 

315 f'_serialize_type_{shape.type_name}', 

316 self._default_serialize, 

317 ) 

318 method(serialized, value, shape, prefix=prefix) 

319 

320 def _serialize_type_structure(self, serialized, value, shape, prefix=''): 

321 members = shape.members 

322 for key, value in value.items(): 

323 member_shape = members[key] 

324 member_prefix = self._get_serialized_name(member_shape, key) 

325 if prefix: 

326 member_prefix = f'{prefix}.{member_prefix}' 

327 self._serialize(serialized, value, member_shape, member_prefix) 

328 

329 def _serialize_type_list(self, serialized, value, shape, prefix=''): 

330 if not value: 

331 # The query protocol serializes empty lists. 

332 serialized[prefix] = '' 

333 return 

334 if self._is_shape_flattened(shape): 

335 list_prefix = prefix 

336 if shape.member.serialization.get('name'): 

337 name = self._get_serialized_name(shape.member, default_name='') 

338 # Replace '.Original' with '.{name}'. 

339 list_prefix = '.'.join(prefix.split('.')[:-1] + [name]) 

340 else: 

341 list_name = shape.member.serialization.get('name', 'member') 

342 list_prefix = f'{prefix}.{list_name}' 

343 for i, element in enumerate(value, 1): 

344 element_prefix = f'{list_prefix}.{i}' 

345 element_shape = shape.member 

346 self._serialize(serialized, element, element_shape, element_prefix) 

347 

348 def _serialize_type_map(self, serialized, value, shape, prefix=''): 

349 if self._is_shape_flattened(shape): 

350 full_prefix = prefix 

351 else: 

352 full_prefix = f'{prefix}.entry' 

353 template = full_prefix + '.{i}.{suffix}' 

354 key_shape = shape.key 

355 value_shape = shape.value 

356 key_suffix = self._get_serialized_name(key_shape, default_name='key') 

357 value_suffix = self._get_serialized_name(value_shape, 'value') 

358 for i, key in enumerate(value, 1): 

359 key_prefix = template.format(i=i, suffix=key_suffix) 

360 value_prefix = template.format(i=i, suffix=value_suffix) 

361 self._serialize(serialized, key, key_shape, key_prefix) 

362 self._serialize(serialized, value[key], value_shape, value_prefix) 

363 

364 def _serialize_type_blob(self, serialized, value, shape, prefix=''): 

365 # Blob args must be base64 encoded. 

366 serialized[prefix] = self._get_base64(value) 

367 

368 def _serialize_type_timestamp(self, serialized, value, shape, prefix=''): 

369 serialized[prefix] = self._convert_timestamp_to_str( 

370 value, shape.serialization.get('timestampFormat') 

371 ) 

372 

373 def _serialize_type_boolean(self, serialized, value, shape, prefix=''): 

374 if value: 

375 serialized[prefix] = 'true' 

376 else: 

377 serialized[prefix] = 'false' 

378 

379 def _default_serialize(self, serialized, value, shape, prefix=''): 

380 serialized[prefix] = value 

381 

382 def _serialize_type_float(self, serialized, value, shape, prefix=''): 

383 serialized[prefix] = self._handle_float(value) 

384 

385 def _serialize_type_double(self, serialized, value, shape, prefix=''): 

386 self._serialize_type_float(serialized, value, shape, prefix) 

387 

388 

389class EC2Serializer(QuerySerializer): 

390 """EC2 specific customizations to the query protocol serializers. 

391 

392 The EC2 model is almost, but not exactly, similar to the query protocol 

393 serializer. This class encapsulates those differences. The model 

394 will have be marked with a ``protocol`` of ``ec2``, so you don't need 

395 to worry about wiring this class up correctly. 

396 

397 """ 

398 

399 def _get_serialized_name(self, shape, default_name): 

400 # Returns the serialized name for the shape if it exists. 

401 # Otherwise it will return the passed in capitalized default_name. 

402 if 'queryName' in shape.serialization: 

403 return shape.serialization['queryName'] 

404 elif 'name' in shape.serialization: 

405 # A locationName is always capitalized 

406 # on input for the ec2 protocol. 

407 name = shape.serialization['name'] 

408 return name[0].upper() + name[1:] 

409 else: 

410 return default_name 

411 

412 def _serialize_type_list(self, serialized, value, shape, prefix=''): 

413 for i, element in enumerate(value, 1): 

414 element_prefix = f'{prefix}.{i}' 

415 element_shape = shape.member 

416 self._serialize(serialized, element, element_shape, element_prefix) 

417 

418 

419class JSONSerializer(Serializer): 

420 TIMESTAMP_FORMAT = 'unixtimestamp' 

421 

422 def serialize_to_request(self, parameters, operation_model): 

423 target = '{}.{}'.format( 

424 operation_model.metadata['targetPrefix'], 

425 operation_model.name, 

426 ) 

427 json_version = operation_model.metadata['jsonVersion'] 

428 serialized = self._create_default_request() 

429 serialized['method'] = operation_model.http.get( 

430 'method', self.DEFAULT_METHOD 

431 ) 

432 serialized['headers'] = { 

433 'X-Amz-Target': target, 

434 'Content-Type': f'application/x-amz-json-{json_version}', 

435 } 

436 self._handle_query_compatible_trait(operation_model, serialized) 

437 

438 body = self.MAP_TYPE() 

439 input_shape = operation_model.input_shape 

440 if input_shape is not None: 

441 self._serialize(body, parameters, input_shape) 

442 serialized['body'] = json.dumps(body).encode(self.DEFAULT_ENCODING) 

443 

444 host_prefix = self._expand_host_prefix(parameters, operation_model) 

445 if host_prefix is not None: 

446 serialized['host_prefix'] = host_prefix 

447 

448 return serialized 

449 

450 def _serialize(self, serialized, value, shape, key=None): 

451 method = getattr( 

452 self, 

453 f'_serialize_type_{shape.type_name}', 

454 self._default_serialize, 

455 ) 

456 method(serialized, value, shape, key) 

457 

458 def _serialize_type_structure(self, serialized, value, shape, key): 

459 if shape.is_document_type: 

460 serialized[key] = value 

461 else: 

462 if key is not None: 

463 # If a key is provided, this is a result of a recursive 

464 # call so we need to add a new child dict as the value 

465 # of the passed in serialized dict. We'll then add 

466 # all the structure members as key/vals in the new serialized 

467 # dictionary we just created. 

468 new_serialized = self.MAP_TYPE() 

469 serialized[key] = new_serialized 

470 serialized = new_serialized 

471 members = shape.members 

472 for member_key, member_value in value.items(): 

473 member_shape = members[member_key] 

474 if 'name' in member_shape.serialization: 

475 member_key = member_shape.serialization['name'] 

476 self._serialize( 

477 serialized, member_value, member_shape, member_key 

478 ) 

479 

480 def _serialize_type_map(self, serialized, value, shape, key): 

481 map_obj = self.MAP_TYPE() 

482 serialized[key] = map_obj 

483 for sub_key, sub_value in value.items(): 

484 self._serialize(map_obj, sub_value, shape.value, sub_key) 

485 

486 def _serialize_type_list(self, serialized, value, shape, key): 

487 list_obj = [] 

488 serialized[key] = list_obj 

489 for list_item in value: 

490 wrapper = {} 

491 # The JSON list serialization is the only case where we aren't 

492 # setting a key on a dict. We handle this by using 

493 # a __current__ key on a wrapper dict to serialize each 

494 # list item before appending it to the serialized list. 

495 self._serialize(wrapper, list_item, shape.member, "__current__") 

496 list_obj.append(wrapper["__current__"]) 

497 

498 def _default_serialize(self, serialized, value, shape, key): 

499 serialized[key] = value 

500 

501 def _serialize_type_timestamp(self, serialized, value, shape, key): 

502 serialized[key] = self._convert_timestamp_to_str( 

503 value, shape.serialization.get('timestampFormat') 

504 ) 

505 

506 def _serialize_type_blob(self, serialized, value, shape, key): 

507 serialized[key] = self._get_base64(value) 

508 

509 def _serialize_type_float(self, serialized, value, shape, prefix=''): 

510 if isinstance(value, decimal.Decimal): 

511 value = float(value) 

512 serialized[prefix] = self._handle_float(value) 

513 

514 def _serialize_type_double(self, serialized, value, shape, prefix=''): 

515 self._serialize_type_float(serialized, value, shape, prefix) 

516 

517 

518class CBORSerializer(Serializer): 

519 UNSIGNED_INT_MAJOR_TYPE = 0 

520 NEGATIVE_INT_MAJOR_TYPE = 1 

521 BLOB_MAJOR_TYPE = 2 

522 STRING_MAJOR_TYPE = 3 

523 LIST_MAJOR_TYPE = 4 

524 MAP_MAJOR_TYPE = 5 

525 TAG_MAJOR_TYPE = 6 

526 FLOAT_AND_SIMPLE_MAJOR_TYPE = 7 

527 

528 def _serialize_data_item(self, serialized, value, shape, key=None): 

529 method = getattr(self, f'_serialize_type_{shape.type_name}') 

530 if method is None: 

531 raise ValueError( 

532 f"Unrecognized C2J type: {shape.type_name}, unable to " 

533 f"serialize request" 

534 ) 

535 method(serialized, value, shape, key) 

536 

537 def _serialize_type_integer(self, serialized, value, shape, key): 

538 if value >= 0: 

539 major_type = self.UNSIGNED_INT_MAJOR_TYPE 

540 else: 

541 major_type = self.NEGATIVE_INT_MAJOR_TYPE 

542 # The only differences in serializing negative and positive integers is 

543 # that for negative, we set the major type to 1 and set the value to -1 

544 # minus the value 

545 value = -1 - value 

546 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

547 value 

548 ) 

549 initial_byte = self._get_initial_byte(major_type, additional_info) 

550 if num_bytes == 0: 

551 serialized.extend(initial_byte) 

552 else: 

553 serialized.extend(initial_byte + value.to_bytes(num_bytes, "big")) 

554 

555 def _serialize_type_long(self, serialized, value, shape, key): 

556 self._serialize_type_integer(serialized, value, shape, key) 

557 

558 def _serialize_type_blob(self, serialized, value, shape, key): 

559 if isinstance(value, str): 

560 value = value.encode('utf-8') 

561 elif not isinstance(value, (bytes, bytearray)): 

562 # We support file-like objects for blobs; these already have been 

563 # validated to ensure they have a read method 

564 value = value.read() 

565 length = len(value) 

566 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

567 length 

568 ) 

569 initial_byte = self._get_initial_byte( 

570 self.BLOB_MAJOR_TYPE, additional_info 

571 ) 

572 if num_bytes == 0: 

573 serialized.extend(initial_byte) 

574 else: 

575 serialized.extend(initial_byte + length.to_bytes(num_bytes, "big")) 

576 serialized.extend(value) 

577 

578 def _serialize_type_string(self, serialized, value, shape, key): 

579 encoded = value.encode('utf-8') 

580 length = len(encoded) 

581 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

582 length 

583 ) 

584 initial_byte = self._get_initial_byte( 

585 self.STRING_MAJOR_TYPE, additional_info 

586 ) 

587 if num_bytes == 0: 

588 serialized.extend(initial_byte + encoded) 

589 else: 

590 serialized.extend( 

591 initial_byte + length.to_bytes(num_bytes, "big") + encoded 

592 ) 

593 

594 def _serialize_type_list(self, serialized, value, shape, key): 

595 length = len(value) 

596 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

597 length 

598 ) 

599 initial_byte = self._get_initial_byte( 

600 self.LIST_MAJOR_TYPE, additional_info 

601 ) 

602 if num_bytes == 0: 

603 serialized.extend(initial_byte) 

604 else: 

605 serialized.extend(initial_byte + length.to_bytes(num_bytes, "big")) 

606 for item in value: 

607 self._serialize_data_item(serialized, item, shape.member) 

608 

609 def _serialize_type_map(self, serialized, value, shape, key): 

610 length = len(value) 

611 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

612 length 

613 ) 

614 initial_byte = self._get_initial_byte( 

615 self.MAP_MAJOR_TYPE, additional_info 

616 ) 

617 if num_bytes == 0: 

618 serialized.extend(initial_byte) 

619 else: 

620 serialized.extend(initial_byte + length.to_bytes(num_bytes, "big")) 

621 for key_item, item in value.items(): 

622 self._serialize_data_item(serialized, key_item, shape.key) 

623 self._serialize_data_item(serialized, item, shape.value) 

624 

625 def _serialize_type_structure(self, serialized, value, shape, key): 

626 if key is not None: 

627 # For nested structures, we need to serialize the key first 

628 self._serialize_data_item(serialized, key, shape.key_shape) 

629 

630 # Remove `None` values from the dictionary 

631 value = {k: v for k, v in value.items() if v is not None} 

632 

633 map_length = len(value) 

634 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

635 map_length 

636 ) 

637 initial_byte = self._get_initial_byte( 

638 self.MAP_MAJOR_TYPE, additional_info 

639 ) 

640 if num_bytes == 0: 

641 serialized.extend(initial_byte) 

642 else: 

643 serialized.extend( 

644 initial_byte + map_length.to_bytes(num_bytes, "big") 

645 ) 

646 

647 members = shape.members 

648 for member_key, member_value in value.items(): 

649 member_shape = members[member_key] 

650 if 'name' in member_shape.serialization: 

651 member_key = member_shape.serialization['name'] 

652 if member_value is not None: 

653 self._serialize_type_string(serialized, member_key, None, None) 

654 self._serialize_data_item( 

655 serialized, member_value, member_shape 

656 ) 

657 

658 def _serialize_type_timestamp(self, serialized, value, shape, key): 

659 timestamp = self._convert_timestamp_to_str(value) 

660 tag = 1 # Use tag 1 for unix timestamp 

661 initial_byte = self._get_initial_byte(self.TAG_MAJOR_TYPE, tag) 

662 serialized.extend(initial_byte) # Tagging the timestamp 

663 additional_info, num_bytes = self._get_additional_info_and_num_bytes( 

664 timestamp 

665 ) 

666 

667 if num_bytes == 0: 

668 initial_byte = self._get_initial_byte( 

669 self.UNSIGNED_INT_MAJOR_TYPE, timestamp 

670 ) 

671 serialized.extend(initial_byte) 

672 else: 

673 initial_byte = self._get_initial_byte( 

674 self.UNSIGNED_INT_MAJOR_TYPE, additional_info 

675 ) 

676 serialized.extend( 

677 initial_byte + timestamp.to_bytes(num_bytes, "big") 

678 ) 

679 

680 def _serialize_type_float(self, serialized, value, shape, key): 

681 if self._is_special_number(value): 

682 serialized.extend( 

683 self._get_bytes_for_special_numbers(value) 

684 ) # Handle special values like NaN or Infinity 

685 else: 

686 initial_byte = self._get_initial_byte( 

687 self.FLOAT_AND_SIMPLE_MAJOR_TYPE, 26 

688 ) 

689 serialized.extend(initial_byte + struct.pack(">f", value)) 

690 

691 def _serialize_type_double(self, serialized, value, shape, key): 

692 if self._is_special_number(value): 

693 serialized.extend( 

694 self._get_bytes_for_special_numbers(value) 

695 ) # Handle special values like NaN or Infinity 

696 else: 

697 initial_byte = self._get_initial_byte( 

698 self.FLOAT_AND_SIMPLE_MAJOR_TYPE, 27 

699 ) 

700 serialized.extend(initial_byte + struct.pack(">d", value)) 

701 

702 def _serialize_type_boolean(self, serialized, value, shape, key): 

703 additional_info = 21 if value else 20 

704 serialized.extend( 

705 self._get_initial_byte( 

706 self.FLOAT_AND_SIMPLE_MAJOR_TYPE, additional_info 

707 ) 

708 ) 

709 

710 def _get_additional_info_and_num_bytes(self, value): 

711 # Values under 24 can be stored in the initial byte and don't need further 

712 # encoding 

713 if value < 24: 

714 return value, 0 

715 # Values between 24 and 255 (inclusive) can be stored in 1 byte and 

716 # correspond to additional info 24 

717 elif value < 256: 

718 return 24, 1 

719 # Values up to 65535 can be stored in two bytes and correspond to additional 

720 # info 25 

721 elif value < 65536: 

722 return 25, 2 

723 # Values up to 4294967296 can be stored in four bytes and correspond to 

724 # additional info 26 

725 elif value < 4294967296: 

726 return 26, 4 

727 # The maximum number of bytes in a definite length data items is 8 which 

728 # to additional info 27 

729 else: 

730 return 27, 8 

731 

732 def _get_initial_byte(self, major_type, additional_info): 

733 # The highest order three bits are the major type, so we need to bitshift the 

734 # major type by 5 

735 major_type_bytes = major_type << 5 

736 return (major_type_bytes | additional_info).to_bytes(1, "big") 

737 

738 def _is_special_number(self, value): 

739 return any( 

740 [ 

741 value == float('inf'), 

742 value == float('-inf'), 

743 math.isnan(value), 

744 ] 

745 ) 

746 

747 def _get_bytes_for_special_numbers(self, value): 

748 additional_info = 25 

749 initial_byte = self._get_initial_byte( 

750 self.FLOAT_AND_SIMPLE_MAJOR_TYPE, additional_info 

751 ) 

752 if value == float('inf'): 

753 return initial_byte + struct.pack(">H", 0x7C00) 

754 elif value == float('-inf'): 

755 return initial_byte + struct.pack(">H", 0xFC00) 

756 elif math.isnan(value): 

757 return initial_byte + struct.pack(">H", 0x7E00) 

758 

759 

760class BaseRestSerializer(Serializer): 

761 """Base class for rest protocols. 

762 

763 The only variance between the various rest protocols is the 

764 way that the body is serialized. All other aspects (headers, uri, etc.) 

765 are the same and logic for serializing those aspects lives here. 

766 

767 Subclasses must implement the ``_serialize_body_params`` method. 

768 

769 """ 

770 

771 QUERY_STRING_TIMESTAMP_FORMAT = 'iso8601' 

772 HEADER_TIMESTAMP_FORMAT = 'rfc822' 

773 # This is a list of known values for the "location" key in the 

774 # serialization dict. The location key tells us where on the request 

775 # to put the serialized value. 

776 KNOWN_LOCATIONS = ['uri', 'querystring', 'header', 'headers'] 

777 

778 def serialize_to_request(self, parameters, operation_model): 

779 serialized = self._create_default_request() 

780 serialized['method'] = operation_model.http.get( 

781 'method', self.DEFAULT_METHOD 

782 ) 

783 shape = operation_model.input_shape 

784 

785 host_prefix = self._expand_host_prefix(parameters, operation_model) 

786 if host_prefix is not None: 

787 serialized['host_prefix'] = host_prefix 

788 

789 if shape is None: 

790 serialized['url_path'] = operation_model.http['requestUri'] 

791 return serialized 

792 shape_members = shape.members 

793 # While the ``serialized`` key holds the final serialized request 

794 # data, we need interim dicts for the various locations of the 

795 # request. We need this for the uri_path_kwargs and the 

796 # query_string_kwargs because they are templated, so we need 

797 # to gather all the needed data for the string template, 

798 # then we render the template. The body_kwargs is needed 

799 # because once we've collected them all, we run them through 

800 # _serialize_body_params, which for rest-json, creates JSON, 

801 # and for rest-xml, will create XML. This is what the 

802 # ``partitioned`` dict below is for. 

803 partitioned = { 

804 'uri_path_kwargs': self.MAP_TYPE(), 

805 'query_string_kwargs': self.MAP_TYPE(), 

806 'body_kwargs': self.MAP_TYPE(), 

807 'headers': self.MAP_TYPE(), 

808 } 

809 for param_name, param_value in parameters.items(): 

810 if param_value is None: 

811 # Don't serialize any parameter with a None value. 

812 continue 

813 self._partition_parameters( 

814 partitioned, param_name, param_value, shape_members 

815 ) 

816 serialized['url_path'] = self._render_uri_template( 

817 operation_model.http['requestUri'], partitioned['uri_path_kwargs'] 

818 ) 

819 

820 if 'authPath' in operation_model.http: 

821 serialized['auth_path'] = self._render_uri_template( 

822 operation_model.http['authPath'], 

823 partitioned['uri_path_kwargs'], 

824 ) 

825 # Note that we lean on the http implementation to handle the case 

826 # where the requestUri path already has query parameters. 

827 # The bundled http client, requests, already supports this. 

828 serialized['query_string'] = partitioned['query_string_kwargs'] 

829 if partitioned['headers']: 

830 serialized['headers'] = partitioned['headers'] 

831 self._serialize_payload( 

832 partitioned, parameters, serialized, shape, shape_members 

833 ) 

834 self._serialize_content_type(serialized, shape, shape_members) 

835 

836 return serialized 

837 

838 def _render_uri_template(self, uri_template, params): 

839 # We need to handle two cases:: 

840 # 

841 # /{Bucket}/foo 

842 # /{Key+}/bar 

843 # A label ending with '+' is greedy. There can only 

844 # be one greedy key. 

845 encoded_params = {} 

846 for template_param in re.findall(r'{(.*?)}', uri_template): 

847 if template_param.endswith('+'):