From 2a54871ea7020fae08d84f83cb167cb6f2659ed3 Mon Sep 17 00:00:00 2001 From: George Fu Date: Fri, 9 Oct 2026 02:53:27 +0000 Subject: [PATCH 1/6] Generate schemas as on-demand hydration from tuples --- codegen-output/aws-json-1-0/pyproject.toml | 4 + .../src/awsjson10/_private/schemas.py | 2031 ++-- .../aws-json-1-0/src/awsjson10/models.py | 1843 ++-- codegen-output/aws-json-1-1/pyproject.toml | 4 + .../src/awsjson11/_private/schemas.py | 2116 ++-- .../aws-json-1-1/src/awsjson11/models.py | 2014 ++-- codegen-output/aws-query/pyproject.toml | 4 + .../src/awsquery/_private/schemas.py | 2680 ++--- .../aws-query/src/awsquery/models.py | 2329 ++-- codegen-output/ec2-query/pyproject.toml | 4 + .../src/ec2query/_private/schemas.py | 2251 ++-- .../ec2-query/src/ec2query/models.py | 1909 ++-- codegen-output/rest-json-1/pyproject.toml | 4 + .../src/restjson/_private/schemas.py | 9514 +++++++---------- .../rest-json-1/src/restjson/models.py | 8879 ++++++--------- .../rest-xml-with-namespace/pyproject.toml | 4 + .../restxmlwithnamespace/_private/schemas.py | 697 +- .../src/restxmlwithnamespace/models.py | 251 +- codegen-output/rest-xml/pyproject.toml | 4 + .../rest-xml/src/restxml/_private/schemas.py | 6857 +++++------- codegen-output/rest-xml/src/restxml/models.py | 5773 ++++------ codegen-output/rpcv2-cbor/pyproject.toml | 4 + .../src/rpcv2cbor/_private/schemas.py | 1791 ++-- .../rpcv2-cbor/src/rpcv2cbor/models.py | 1924 ++-- .../smithy/python/codegen/RuntimeTypes.java | 4 + .../codegen/generators/ListGenerator.java | 4 +- .../codegen/generators/MapGenerator.java | 4 +- .../MemberDeserializerGenerator.java | 13 +- .../generators/MemberSerializerGenerator.java | 13 +- .../generators/OperationGenerator.java | 25 +- .../codegen/generators/SchemaGenerator.java | 529 +- .../codegen/generators/SetupGenerator.java | 4 + .../generators/StructureGenerator.java | 28 +- .../codegen/generators/UnionGenerator.java | 18 +- .../tests/unit/aio/test_protocols.py | 17 +- packages/smithy-cbor/tests/benchmark/model.py | 18 +- .../src/smithy_core/_schema_compact.py | 231 + .../smithy-core/src/smithy_core/schemas.py | 44 +- .../tests/unit/aio/_pipeline_harness.py | 28 +- .../smithy-core/tests/unit/test_schemas.py | 13 +- .../tests/unit/aio/test_protocols.py | 47 +- 41 files changed, 21837 insertions(+), 32094 deletions(-) create mode 100644 packages/smithy-core/src/smithy_core/_schema_compact.py diff --git a/codegen-output/aws-json-1-0/pyproject.toml b/codegen-output/aws-json-1-0/pyproject.toml index de6d7aa27..0cde77bd1 100644 --- a/codegen-output/aws-json-1-0/pyproject.toml +++ b/codegen-output/aws-json-1-0/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py b/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py index 6ca7db652..d72b8c4e3 100644 --- a/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py +++ b/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py @@ -2,1225 +2,952 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - BYTE, - DOCUMENT, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -CLIENT_OPTIONAL_DEFAULTS = Schema.collection( - id=ShapeID("aws.protocoltests.json10#ClientOptionalDefaults"), - members={ - "member": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - } - }, -) - -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("aws.protocoltests.json10#ComplexNestedErrorData"), - members={ - "Foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="Fooooo")], - } - }, -) - -COMPLEX_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.json10#ComplexError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, -) - -CONTENT_TYPE_PARAMETERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#ContentTypeParametersInput"), - members={"value": {"target": INTEGER}}, -) - -CONTENT_TYPE_PARAMETERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#ContentTypeParametersOutput") -) - -CONTENT_TYPE_PARAMETERS = Schema( - id=ShapeID("aws.protocoltests.json10#ContentTypeParameters"), - shape_type=ShapeType.OPERATION, -) - -TEST_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.json10#TestEnum"), - shape_type=ShapeType.ENUM, - members={"FOO": {"target": UNIT}, "BAR": {"target": UNIT}, "BAZ": {"target": UNIT}}, -) - -TEST_INT_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.json10#TestIntEnum"), - shape_type=ShapeType.INT_ENUM, - members={"ONE": {"target": UNIT}, "TWO": {"target": UNIT}}, -) - -TEST_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.json10#TestStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -TEST_STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.json10#TestStringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -DEFAULTS = Schema.collection( - id=ShapeID("aws.protocoltests.json10#Defaults"), - members={ - "defaultString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultList": { - "target": TEST_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultDocumentMap": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultDocumentString": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultDocumentBoolean": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultDocumentList": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultNullDocument": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=None)], - }, - "defaultTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "defaultBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="YWJj")], - }, - "defaultByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=10)], - }, - "defaultLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=100)], - }, - "defaultFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultMap": { - "target": TEST_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultEnum": { - "target": TEST_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="FOO")], - }, - "defaultIntEnum": { - "target": TEST_INT_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "falseBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=False)], - }, - "emptyBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "zeroByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - "zeroDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - }, -) - -FAREWELL = Schema.collection( - id=ShapeID("aws.protocoltests.json10#Farewell"), - members={ - "phrase": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="bye")], - } - }, -) - -DIALOG = Schema.collection( - id=ShapeID("aws.protocoltests.json10#Dialog"), - members={ - "language": {"target": STRING}, - "greeting": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "farewell": {"target": FAREWELL}, - }, -) - -DIALOG_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.json10#DialogList"), - shape_type=ShapeType.LIST, - members={"member": {"target": DIALOG}}, -) - -DIALOG_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.json10#DialogMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": DIALOG}}, -) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#EmptyInputAndEmptyOutputInput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#EmptyInputAndEmptyOutputOutput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.json10#EmptyInputAndEmptyOutput"), - shape_type=ShapeType.OPERATION, -) - -ENDPOINT_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#EndpointOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#EndpointOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json10#EndpointOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo."}), - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#EndpointWithHostLabelOperationInput"), - members={ - "label": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#EndpointWithHostLabelOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json10#EndpointWithHostLabelOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo.{label}."}), - ) - ], -) - -FOO_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.json10#FooError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="server")], -) - -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#GreetingWithErrorsInput"), - members={"greeting": {"target": STRING}}, -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#GreetingWithErrorsOutput"), - members={"greeting": {"target": STRING}}, -) - -INVALID_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.json10#InvalidGreeting"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={"Message": {"target": STRING}}, -) - -GREETING_WITH_ERRORS = Schema( - id=ShapeID("aws.protocoltests.json10#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, -) - -HOST_WITH_PATH_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#HostWithPathOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HOST_WITH_PATH_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#HostWithPathOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HOST_WITH_PATH_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json10#HostWithPathOperation"), - shape_type=ShapeType.OPERATION, -) - -FOO_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, +n0 = "aws.protocoltests.json10" +_COD = "ClientOptionalDefaults" +_m = "member" +_s = "smithy.api#default" +_CNED = "ComplexNestedErrorData" +_F = "Foo" +_sN = "smithy.api#jsonName" +_Fo = "Fooooo" +_CE = "ComplexError" +_sm = "smithy.api#error" +_c = "client" +_TL = "TopLevel" +_N = "Nested" +_CTPI = "ContentTypeParametersInput" +_v = "value" +_CTPO = "ContentTypeParametersOutput" +_CTP = "ContentTypeParameters" +_TE = "TestEnum" +_FOO = "FOO" +_BAR = "BAR" +_BAZ = "BAZ" +_TIE = "TestIntEnum" +_ONE = "ONE" +_TWO = "TWO" +_TSL = "TestStringList" +_TSM = "TestStringMap" +_k = "key" +_D = "Defaults" +_dS = "defaultString" +_h = "hi" +_dB = "defaultBoolean" +_dL = "defaultList" +_dDM = "defaultDocumentMap" +_dDS = "defaultDocumentString" +_dDB = "defaultDocumentBoolean" +_dDL = "defaultDocumentList" +_dND = "defaultNullDocument" +_dT = "defaultTimestamp" +_dBe = "defaultBlob" +_YWJ = "YWJj" +_dBef = "defaultByte" +_dSe = "defaultShort" +_dI = "defaultInteger" +_dLe = "defaultLong" +_dF = "defaultFloat" +_dD = "defaultDouble" +_dM = "defaultMap" +_dE = "defaultEnum" +_dIE = "defaultIntEnum" +_eS = "emptyString" +_v_ = "" +_fB = "falseBoolean" +_eB = "emptyBlob" +_zB = "zeroByte" +_zS = "zeroShort" +_zI = "zeroInteger" +_zL = "zeroLong" +_zF = "zeroFloat" +_zD = "zeroDouble" +_Fa = "Farewell" +_p = "phrase" +_b = "bye" +_Di = "Dialog" +_l = "language" +_g = "greeting" +_f = "farewell" +_DL = "DialogList" +_DM = "DialogMap" +_EIAEOI = "EmptyInputAndEmptyOutputInput" +_EIAEOO = "EmptyInputAndEmptyOutputOutput" +_EIAEO = "EmptyInputAndEmptyOutput" +_EOI = "EndpointOperationInput" +_sSI = "smithy.synthetic#originalShapeId" +_sU = "smithy.api#Unit" +_EOO = "EndpointOperationOutput" +_EO = "EndpointOperation" +_smi = "smithy.api#endpoint" +_EWHLOI = "EndpointWithHostLabelOperationInput" +_la = "label" +_sL = "smithy.api#hostLabel" +_smit = "smithy.api#required" +_EWHLOO = "EndpointWithHostLabelOperationOutput" +_EWHLO = "EndpointWithHostLabelOperation" +_FE = "FooError" +_se = "server" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_IG = "InvalidGreeting" +_M = "Message" +_GWE = "GreetingWithErrors" +_HWPOI = "HostWithPathOperationInput" +_HWPOO = "HostWithPathOperationOutput" +_HWPO = "HostWithPathOperation" +n1 = "aws.protocoltests.shared" +_FEo = "FooEnum" +_ZERO = "ZERO" +_IE = "IntegerEnum" +_A = "A" +_B = "B" +_C = "C" +_SL = "StringList" +_SM = "StringMap" +_GS = "GreetingStruct" +_MU = "MyUnion" +_sV = "stringValue" +_bV = "booleanValue" +_nV = "numberValue" +_bVl = "blobValue" +_tV = "timestampValue" +_eV = "enumValue" +_iEV = "intEnumValue" +_lV = "listValue" +_mV = "mapValue" +_sVt = "structureValue" +_JUI = "JsonUnionsInput" +_co = "contents" +_JUO = "JsonUnionsOutput" +_JU = "JsonUnions" +_NIANOI = "NoInputAndNoOutputInput" +_NIANOO = "NoInputAndNoOutputOutput" +_NIANO = "NoInputAndNoOutput" +_NIAOI = "NoInputAndOutputInput" +_NIAOO = "NoInputAndOutputOutput" +_NIAO = "NoInputAndOutput" +_OWDI = "OperationWithDefaultsInput" +_d = "defaults" +_cOD = "clientOptionalDefaults" +_tLD = "topLevelDefault" +_oTLD = "otherTopLevelDefault" +_OWDO = "OperationWithDefaultsOutput" +_OWD = "OperationWithDefaults" +_di = "dialog" +_dLi = "dialogList" +_dMi = "dialogMap" +_OWNSI = "OperationWithNestedStructureInput" +_tL = "topLevel" +_OWNSO = "OperationWithNestedStructureOutput" +_OWNS = "OperationWithNestedStructure" +_OWRMI = "OperationWithRequiredMembersInput" +_RSL = "RequiredStringList" +_RSM = "RequiredStringMap" +_OWRMO = "OperationWithRequiredMembersOutput" +_rS = "requiredString" +_rB = "requiredBoolean" +_rL = "requiredList" +_rT = "requiredTimestamp" +_rBe = "requiredBlob" +_rBeq = "requiredByte" +_rSe = "requiredShort" +_rI = "requiredInteger" +_rLe = "requiredLong" +_rF = "requiredFloat" +_rD = "requiredDouble" +_rM = "requiredMap" +_OWRM = "OperationWithRequiredMembers" +_OWRMWDI = "OperationWithRequiredMembersWithDefaultsInput" +_RE = "RequiredEnum" +_RIE = "RequiredIntEnum" +_OWRMWDO = "OperationWithRequiredMembersWithDefaultsOutput" +_YY = "YmxvYg==" +_rE = "requiredEnum" +_rIE = "requiredIntEnum" +_OWRMWD = "OperationWithRequiredMembersWithDefaults" +_PWCEI = "PutWithContentEncodingInput" +_e = "encoding" +_sH = "smithy.api#httpHeader" +_CE_ = "Content-Encoding" +_da = "data" +_PWCEO = "PutWithContentEncodingOutput" +_PWCE = "PutWithContentEncoding" +_sC = "smithy.api#requestCompression" +_QIOI = "QueryIncompatibleOperationInput" +_QIOO = "QueryIncompatibleOperationOutput" +_QIO = "QueryIncompatibleOperation" +_SSPI = "SimpleScalarPropertiesInput" +_fV = "floatValue" +_dV = "doubleValue" +_SSPO = "SimpleScalarPropertiesOutput" +_SSP = "SimpleScalarProperties" +_JR = "JsonRpc10" +_a = "aws.auth#sigv4" +_a_ = "aws.protocols#awsJson1_0" +_sB = "smithy.rules#endpointBdd" +_aw = "aws.api#service" + +CLIENT_OPTIONAL_DEFAULTS = (18, n0, _COD, 0, (_m,), ((7, {_s: 0}),)) + +COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, {_sN: _Fo}),)) + +COMPLEX_ERROR = ( + 18, + n0, + _CE, + {_sm: _c}, + (_TL, _N), + ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), +) + +CONTENT_TYPE_PARAMETERS_INPUT = (18, n0, _CTPI, 0, (_v,), ((7, 0),)) + +CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n0, _CTPO, 0) + +CONTENT_TYPE_PARAMETERS = ( + 23, + n0, + _CTP, + 0, + CONTENT_TYPE_PARAMETERS_INPUT, + CONTENT_TYPE_PARAMETERS_OUTPUT, + (), +) + +TEST_ENUM = (14, n0, _TE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) + +TEST_INT_ENUM = (15, n0, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) + +TEST_STRING_LIST = (16, n0, _TSL, 0, (_m,), ((3, 0),)) + +TEST_STRING_MAP = (17, n0, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) + +DEFAULTS = ( + 18, + n0, + _D, + 0, + ( + _dS, + _dB, + _dL, + _dDM, + _dDS, + _dDB, + _dDL, + _dND, + _dT, + _dBe, + _dBef, + _dSe, + _dI, + _dLe, + _dF, + _dD, + _dM, + _dE, + _dIE, + _eS, + _fB, + _eB, + _zB, + _zS, + _zI, + _zL, + _zF, + _zD, + ), + ( + (3, {_s: _h}), + (2, {_s: True}), + (TEST_STRING_LIST, {_s: ()}), + (13, {_s: None}), + (13, {_s: _h}), + (13, {_s: True}), + (13, {_s: ()}), + (13, {_s: None}), + (4, {_s: 0}), + (1, {_s: _YWJ}), + (5, {_s: 1}), + (6, {_s: 1}), + (7, {_s: 10}), + (8, {_s: 100}), + (9, {_s: 1.0}), + (10, {_s: 1.0}), + (TEST_STRING_MAP, {_s: None}), + (TEST_ENUM, {_s: _FOO}), + (TEST_INT_ENUM, {_s: 1}), + (3, {_s: _v_}), + (2, {_s: False}), + (1, {_s: _v_}), + (5, {_s: 0}), + (6, {_s: 0}), + (7, {_s: 0}), + (8, {_s: 0}), + (9, {_s: 0.0}), + (10, {_s: 0.0}), + ), ) -INTEGER_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, -) +FAREWELL = (18, n0, _Fa, 0, (_p,), ((3, {_s: _b}),)) -STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) +DIALOG = (18, n0, _Di, 0, (_l, _g, _f), ((3, 0), (3, {_s: _h}), (FAREWELL, 0))) -STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) +DIALOG_LIST = (16, n0, _DL, 0, (_m,), ((DIALOG, 0),)) -GREETING_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, -) +DIALOG_MAP = (17, n0, _DM, 0, (_k, _v), ((3, 0), (DIALOG, 0))) -MY_UNION = Schema.collection( - id=ShapeID("aws.protocoltests.json10#MyUnion"), - shape_type=ShapeType.UNION, - members={ - "stringValue": {"target": STRING}, - "booleanValue": {"target": BOOLEAN}, - "numberValue": {"target": INTEGER}, - "blobValue": {"target": BLOB}, - "timestampValue": {"target": TIMESTAMP}, - "enumValue": {"target": FOO_ENUM}, - "intEnumValue": {"target": INTEGER_ENUM}, - "listValue": {"target": STRING_LIST}, - "mapValue": {"target": STRING_MAP}, - "structureValue": {"target": GREETING_STRUCT}, - }, -) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n0, _EIAEOI, 0) -JSON_UNIONS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#JsonUnionsInput"), - members={"contents": {"target": MY_UNION}}, -) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n0, _EIAEOO, 0) -JSON_UNIONS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#JsonUnionsOutput"), - members={"contents": {"target": MY_UNION}}, +EMPTY_INPUT_AND_EMPTY_OUTPUT = ( + 23, + n0, + _EIAEO, + 0, + EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, + EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + (), ) -JSON_UNIONS = Schema( - id=ShapeID("aws.protocoltests.json10#JsonUnions"), shape_type=ShapeType.OPERATION -) +ENDPOINT_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#NoInputAndNoOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#NoInputAndNoOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +ENDPOINT_OPERATION = ( + 23, + n0, + _EO, + {_smi: MappingProxyType({"hostPrefix": "foo."})}, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), ) -NO_INPUT_AND_NO_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.json10#NoInputAndNoOutput"), - shape_type=ShapeType.OPERATION, -) +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = (18, n0, _EWHLOI, 0, (_la,), ((3, 257),)) -NO_INPUT_AND_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#NoInputAndOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#NoInputAndOutputOutput") +ENDPOINT_WITH_HOST_LABEL_OPERATION = ( + 23, + n0, + _EWHLO, + {_smi: MappingProxyType({"hostPrefix": "foo.{label}."})}, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), ) -NO_INPUT_AND_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.json10#NoInputAndOutput"), - shape_type=ShapeType.OPERATION, -) +FOO_ERROR = (18, n0, _FE, {_sm: _se}) -OPERATION_WITH_DEFAULTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#OperationWithDefaultsInput"), - members={ - "defaults": {"target": DEFAULTS}, - "clientOptionalDefaults": {"target": CLIENT_OPTIONAL_DEFAULTS}, - "topLevelDefault": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "otherTopLevelDefault": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - }, -) +GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, 0, (_g,), ((3, 0),)) -OPERATION_WITH_DEFAULTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#OperationWithDefaultsOutput"), - members={ - "defaultString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultList": { - "target": TEST_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultDocumentMap": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultDocumentString": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultDocumentBoolean": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultDocumentList": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultNullDocument": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=None)], - }, - "defaultTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "defaultBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="YWJj")], - }, - "defaultByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=10)], - }, - "defaultLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=100)], - }, - "defaultFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultMap": { - "target": TEST_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultEnum": { - "target": TEST_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="FOO")], - }, - "defaultIntEnum": { - "target": TEST_INT_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "falseBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=False)], - }, - "emptyBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "zeroByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - "zeroDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - }, -) +GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -OPERATION_WITH_DEFAULTS = Schema( - id=ShapeID("aws.protocoltests.json10#OperationWithDefaults"), - shape_type=ShapeType.OPERATION, -) +INVALID_GREETING = (18, n0, _IG, {_sm: _c}, (_M,), ((3, 0),)) -TOP_LEVEL = Schema.collection( - id=ShapeID("aws.protocoltests.json10#TopLevel"), - members={ - "dialog": { - "target": DIALOG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "dialogList": { - "target": DIALOG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "dialogMap": { - "target": DIALOG_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - }, +GREETING_WITH_ERRORS = ( + 23, + n0, + _GWE, + 0, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR, FOO_ERROR), ) -OPERATION_WITH_NESTED_STRUCTURE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#OperationWithNestedStructureInput"), - members={ - "topLevel": { - "target": TOP_LEVEL, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) +HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) -OPERATION_WITH_NESTED_STRUCTURE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#OperationWithNestedStructureOutput"), - members={ - "dialog": { - "target": DIALOG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "dialogList": { - "target": DIALOG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "dialogMap": { - "target": DIALOG_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - }, -) +HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) -OPERATION_WITH_NESTED_STRUCTURE = Schema( - id=ShapeID("aws.protocoltests.json10#OperationWithNestedStructure"), - shape_type=ShapeType.OPERATION, +HOST_WITH_PATH_OPERATION = ( + 23, + n0, + _HWPO, + 0, + HOST_WITH_PATH_OPERATION_INPUT, + HOST_WITH_PATH_OPERATION_OUTPUT, + (), ) -OPERATION_WITH_REQUIRED_MEMBERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#OperationWithRequiredMembersInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +FOO_ENUM = ( + 14, + n1, + _FEo, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -REQUIRED_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.json10#RequiredStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) +INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -REQUIRED_STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.json10#RequiredStringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) +STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) -OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#OperationWithRequiredMembersOutput"), - members={ - "requiredString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredList": { - "target": REQUIRED_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "requiredMap": { - "target": REQUIRED_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) +STRING_MAP = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -OPERATION_WITH_REQUIRED_MEMBERS = Schema( - id=ShapeID("aws.protocoltests.json10#OperationWithRequiredMembers"), - shape_type=ShapeType.OPERATION, -) +GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) -OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.json10#OperationWithRequiredMembersWithDefaultsInput" +MY_UNION = ( + 19, + n0, + _MU, + 0, + (_sV, _bV, _nV, _bVl, _tV, _eV, _iEV, _lV, _mV, _sVt), + ( + (3, 0), + (2, 0), + (7, 0), + (1, 0), + (4, 0), + (FOO_ENUM, 0), + (INTEGER_ENUM, 0), + (STRING_LIST, 0), + (STRING_MAP, 0), + (GREETING_STRUCT, 0), ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], ) -REQUIRED_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.json10#RequiredEnum"), - shape_type=ShapeType.ENUM, - members={"FOO": {"target": UNIT}, "BAR": {"target": UNIT}, "BAZ": {"target": UNIT}}, -) - -REQUIRED_INT_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.json10#RequiredIntEnum"), - shape_type=ShapeType.INT_ENUM, - members={"ONE": {"target": UNIT}, "TWO": {"target": UNIT}}, -) - -OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.json10#OperationWithRequiredMembersWithDefaultsOutput" +JSON_UNIONS_INPUT = (18, n0, _JUI, 0, (_co,), ((MY_UNION, 0),)) + +JSON_UNIONS_OUTPUT = (18, n0, _JUO, 0, (_co,), ((MY_UNION, 0),)) + +JSON_UNIONS = (23, n0, _JU, 0, JSON_UNIONS_INPUT, JSON_UNIONS_OUTPUT, ()) + +NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n0, _NIANOI, {_sSI: _sU}) + +NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n0, _NIANOO, {_sSI: _sU}) + +NO_INPUT_AND_NO_OUTPUT = ( + 23, + n0, + _NIANO, + 0, + NO_INPUT_AND_NO_OUTPUT_INPUT, + NO_INPUT_AND_NO_OUTPUT_OUTPUT, + (), +) + +NO_INPUT_AND_OUTPUT_INPUT = (18, n0, _NIAOI, {_sSI: _sU}) + +NO_INPUT_AND_OUTPUT_OUTPUT = (18, n0, _NIAOO, 0) + +NO_INPUT_AND_OUTPUT = ( + 23, + n0, + _NIAO, + 0, + NO_INPUT_AND_OUTPUT_INPUT, + NO_INPUT_AND_OUTPUT_OUTPUT, + (), +) + +OPERATION_WITH_DEFAULTS_INPUT = ( + 18, + n0, + _OWDI, + 0, + (_d, _cOD, _tLD, _oTLD), + ((DEFAULTS, 0), (CLIENT_OPTIONAL_DEFAULTS, 0), (3, {_s: _h}), (7, {_s: 0})), +) + +OPERATION_WITH_DEFAULTS_OUTPUT = ( + 18, + n0, + _OWDO, + 0, + ( + _dS, + _dB, + _dL, + _dDM, + _dDS, + _dDB, + _dDL, + _dND, + _dT, + _dBe, + _dBef, + _dSe, + _dI, + _dLe, + _dF, + _dD, + _dM, + _dE, + _dIE, + _eS, + _fB, + _eB, + _zB, + _zS, + _zI, + _zL, + _zF, + _zD, + ), + ( + (3, {_s: _h}), + (2, {_s: True}), + (TEST_STRING_LIST, {_s: ()}), + (13, {_s: None}), + (13, {_s: _h}), + (13, {_s: True}), + (13, {_s: ()}), + (13, {_s: None}), + (4, {_s: 0}), + (1, {_s: _YWJ}), + (5, {_s: 1}), + (6, {_s: 1}), + (7, {_s: 10}), + (8, {_s: 100}), + (9, {_s: 1.0}), + (10, {_s: 1.0}), + (TEST_STRING_MAP, {_s: None}), + (TEST_ENUM, {_s: _FOO}), + (TEST_INT_ENUM, {_s: 1}), + (3, {_s: _v_}), + (2, {_s: False}), + (1, {_s: _v_}), + (5, {_s: 0}), + (6, {_s: 0}), + (7, {_s: 0}), + (8, {_s: 0}), + (9, {_s: 0.0}), + (10, {_s: 0.0}), ), - members={ - "requiredString": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="hi"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredBoolean": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=True), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredList": { - "target": REQUIRED_STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=()), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=1), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredBlob": { - "target": BLOB, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="YmxvYg=="), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredByte": { - "target": BYTE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=1), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredShort": { - "target": SHORT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=1), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredInteger": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=10), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredLong": { - "target": LONG, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=100), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredFloat": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=1.0), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredDouble": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=1.0), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredMap": { - "target": REQUIRED_STRING_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredEnum": { - "target": REQUIRED_ENUM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value="FOO"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "requiredIntEnum": { - "target": REQUIRED_INT_ENUM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=1), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - }, -) - -OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS = Schema( - id=ShapeID("aws.protocoltests.json10#OperationWithRequiredMembersWithDefaults"), - shape_type=ShapeType.OPERATION, -) - -PUT_WITH_CONTENT_ENCODING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#PutWithContentEncodingInput"), - members={ - "encoding": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Encoding") - ], - }, - "data": {"target": STRING}, - }, -) - -PUT_WITH_CONTENT_ENCODING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#PutWithContentEncodingOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -PUT_WITH_CONTENT_ENCODING = Schema( - id=ShapeID("aws.protocoltests.json10#PutWithContentEncoding"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#requestCompression"), - value=MappingProxyType({"encodings": ("gzip",)}), - ) - ], -) - -QUERY_INCOMPATIBLE_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#QueryIncompatibleOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_INCOMPATIBLE_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#QueryIncompatibleOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_INCOMPATIBLE_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json10#QueryIncompatibleOperation"), - shape_type=ShapeType.OPERATION, -) - -SIMPLE_SCALAR_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#SimpleScalarPropertiesInput"), - members={"floatValue": {"target": FLOAT}, "doubleValue": {"target": DOUBLE}}, ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json10#SimpleScalarPropertiesOutput"), - members={"floatValue": {"target": FLOAT}, "doubleValue": {"target": DOUBLE}}, +OPERATION_WITH_DEFAULTS = ( + 23, + n0, + _OWD, + 0, + OPERATION_WITH_DEFAULTS_INPUT, + OPERATION_WITH_DEFAULTS_OUTPUT, + (), +) + +TOP_LEVEL = ( + 18, + n0, + _TL, + 0, + (_di, _dLi, _dMi), + ((DIALOG, 1), (DIALOG_LIST, {_s: ()}), (DIALOG_MAP, {_s: None})), +) + +OPERATION_WITH_NESTED_STRUCTURE_INPUT = (18, n0, _OWNSI, 0, (_tL,), ((TOP_LEVEL, 1),)) + +OPERATION_WITH_NESTED_STRUCTURE_OUTPUT = ( + 18, + n0, + _OWNSO, + 0, + (_di, _dLi, _dMi), + ((DIALOG, 1), (DIALOG_LIST, {_s: ()}), (DIALOG_MAP, {_s: None})), +) + +OPERATION_WITH_NESTED_STRUCTURE = ( + 23, + n0, + _OWNS, + 0, + OPERATION_WITH_NESTED_STRUCTURE_INPUT, + OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, + (), +) + +OPERATION_WITH_REQUIRED_MEMBERS_INPUT = (18, n0, _OWRMI, {_sSI: _sU}) + +REQUIRED_STRING_LIST = (16, n0, _RSL, 0, (_m,), ((3, 0),)) + +REQUIRED_STRING_MAP = (17, n0, _RSM, 0, (_k, _v), ((3, 0), (3, 0))) + +OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT = ( + 18, + n0, + _OWRMO, + 0, + (_rS, _rB, _rL, _rT, _rBe, _rBeq, _rSe, _rI, _rLe, _rF, _rD, _rM), + ( + (3, 1), + (2, 1), + (REQUIRED_STRING_LIST, 1), + (4, 1), + (1, 1), + (5, 1), + (6, 1), + (7, 1), + (8, 1), + (9, 1), + (10, 1), + (REQUIRED_STRING_MAP, 1), + ), ) -SIMPLE_SCALAR_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.json10#SimpleScalarProperties"), - shape_type=ShapeType.OPERATION, +OPERATION_WITH_REQUIRED_MEMBERS = ( + 23, + n0, + _OWRM, + 0, + OPERATION_WITH_REQUIRED_MEMBERS_INPUT, + OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT, + (), +) + +OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT = (18, n0, _OWRMWDI, {_sSI: _sU}) + +REQUIRED_ENUM = (14, n0, _RE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) + +REQUIRED_INT_ENUM = (15, n0, _RIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) + +OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT = ( + 18, + n0, + _OWRMWDO, + 0, + (_rS, _rB, _rL, _rT, _rBe, _rBeq, _rSe, _rI, _rLe, _rF, _rD, _rM, _rE, _rIE), + ( + (3, {_s: _h, _smit: None}), + (2, {_s: True, _smit: None}), + (REQUIRED_STRING_LIST, {_s: (), _smit: None}), + (4, {_s: 1, _smit: None}), + (1, {_s: _YY, _smit: None}), + (5, {_s: 1, _smit: None}), + (6, {_s: 1, _smit: None}), + (7, {_s: 10, _smit: None}), + (8, {_s: 100, _smit: None}), + (9, {_s: 1.0, _smit: None}), + (10, {_s: 1.0, _smit: None}), + (REQUIRED_STRING_MAP, {_s: None, _smit: None}), + (REQUIRED_ENUM, {_s: _FOO, _smit: None}), + (REQUIRED_INT_ENUM, {_s: 1, _smit: None}), + ), ) -JSON_RPC10 = Schema( - id=ShapeID("aws.protocoltests.json10#JsonRpc10"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), value=MappingProxyType({"name": "jsonrpc10"}) - ), - Trait.new(id=ShapeID("aws.protocols#awsJson1_0")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), - } - ), - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), - } - ), - MappingProxyType( - { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), - } - ), - MappingProxyType( +OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS = ( + 23, + n0, + _OWRMWD, + 0, + OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT, + OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT, + (), +) + +PUT_WITH_CONTENT_ENCODING_INPUT = ( + 18, + n0, + _PWCEI, + 0, + (_e, _da), + ((3, {_sH: _CE_}), (3, 0)), +) + +PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) + +PUT_WITH_CONTENT_ENCODING = ( + 23, + n0, + _PWCE, + {_sC: MappingProxyType({"encodings": ("gzip",)})}, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), +) + +QUERY_INCOMPATIBLE_OPERATION_INPUT = (18, n0, _QIOI, {_sSI: _sU}) + +QUERY_INCOMPATIBLE_OPERATION_OUTPUT = (18, n0, _QIOO, {_sSI: _sU}) + +QUERY_INCOMPATIBLE_OPERATION = ( + 23, + n0, + _QIO, + 0, + QUERY_INCOMPATIBLE_OPERATION_INPUT, + QUERY_INCOMPATIBLE_OPERATION_OUTPUT, + (), +) + +SIMPLE_SCALAR_PROPERTIES_INPUT = (18, n0, _SSPI, 0, (_fV, _dV), ((9, 0), (10, 0))) + +SIMPLE_SCALAR_PROPERTIES_OUTPUT = (18, n0, _SSPO, 0, (_fV, _dV), ((9, 0), (10, 0))) + +SIMPLE_SCALAR_PROPERTIES = ( + 23, + n0, + _SSP, + 0, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), +) + +JSON_RPC10 = ( + 21, + n0, + _JR, + { + _a: MappingProxyType({"name": "jsonrpc10"}), + _a_: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://jsonrpc10-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://jsonrpc10.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://jsonrpc10-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://jsonrpc10.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://jsonrpc10.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), - ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType({"sdkId": "JSON RPC 10"}), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonrpc10-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonrpc10.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonrpc10-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonrpc10.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonrpc10.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - ], + _aw: MappingProxyType({"sdkId": "JSON RPC 10"}), + }, ) diff --git a/codegen-output/aws-json-1-0/src/awsjson10/models.py b/codegen-output/aws-json-1-0/src/awsjson10/models.py index 959e3afe0..735ff1bee 100644 --- a/codegen-output/aws-json-1-0/src/awsjson10/models.py +++ b/codegen-output/aws-json-1-0/src/awsjson10/models.py @@ -7,6 +7,7 @@ import logging from typing import Any, Literal, Self, Union +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import Document, TypeRegistry from smithy_core.exceptions import ModeledError, SerializationError @@ -98,13 +99,12 @@ class ClientOptionalDefaults: member: int = 0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS, self) + serializer.write_struct(hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS).members_by_index if self.member is not None: - serializer.write_integer( - _SCHEMA_CLIENT_OPTIONAL_DEFAULTS.members["member"], self.member - ) + serializer.write_integer(members[0], self.member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -113,18 +113,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member"] = de.read_integer( - _SCHEMA_CLIENT_OPTIONAL_DEFAULTS.members["member"] - ) + kwargs["member"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -135,13 +135,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -150,18 +149,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -176,18 +175,15 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[0], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -196,21 +192,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[0]) case 1: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -221,13 +217,12 @@ class ContentTypeParametersInput: value: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT).members_by_index if self.value is not None: - serializer.write_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"], self.value - ) + serializer.write_integer(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -236,20 +231,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"] - ) + kwargs["value"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -268,7 +261,7 @@ class ContentTypeParametersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -280,27 +273,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONTENT_TYPE_PARAMETERS = APIOperation( input=ContentTypeParametersInput, output=ContentTypeParametersOutput, - schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, - input_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, - output_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, + static_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -318,7 +307,7 @@ class TestIntEnum(UnknownEnumMixin, IntEnum): def _serialize_test_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -328,7 +317,7 @@ def _deserialize_test_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -345,7 +334,7 @@ def _serialize_test_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -354,7 +343,7 @@ def _deserialize_test_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -428,85 +417,38 @@ class Defaults: zero_double: float = 0.0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DEFAULTS, self) + serializer.write_struct(hydrate(_SCHEMA_DEFAULTS), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_DEFAULTS.members["defaultString"], self.default_string - ) - serializer.write_boolean( - _SCHEMA_DEFAULTS.members["defaultBoolean"], self.default_boolean - ) - _serialize_test_string_list( - serializer, _SCHEMA_DEFAULTS.members["defaultList"], self.default_list - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentMap"], self.default_document_map - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentString"], - self.default_document_string, - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentBoolean"], - self.default_document_boolean, - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentList"], self.default_document_list - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultNullDocument"], self.default_null_document - ) - serializer.write_timestamp( - _SCHEMA_DEFAULTS.members["defaultTimestamp"], self.default_timestamp - ) - serializer.write_blob( - _SCHEMA_DEFAULTS.members["defaultBlob"], self.default_blob - ) - serializer.write_byte( - _SCHEMA_DEFAULTS.members["defaultByte"], self.default_byte - ) - serializer.write_short( - _SCHEMA_DEFAULTS.members["defaultShort"], self.default_short - ) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["defaultInteger"], self.default_integer - ) - serializer.write_long( - _SCHEMA_DEFAULTS.members["defaultLong"], self.default_long - ) - serializer.write_float( - _SCHEMA_DEFAULTS.members["defaultFloat"], self.default_float - ) - serializer.write_double( - _SCHEMA_DEFAULTS.members["defaultDouble"], self.default_double - ) - _serialize_test_string_map( - serializer, _SCHEMA_DEFAULTS.members["defaultMap"], self.default_map - ) - serializer.write_string( - _SCHEMA_DEFAULTS.members["defaultEnum"], self.default_enum - ) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["defaultIntEnum"], self.default_int_enum - ) - serializer.write_string( - _SCHEMA_DEFAULTS.members["emptyString"], self.empty_string - ) - serializer.write_boolean( - _SCHEMA_DEFAULTS.members["falseBoolean"], self.false_boolean - ) - serializer.write_blob(_SCHEMA_DEFAULTS.members["emptyBlob"], self.empty_blob) - serializer.write_byte(_SCHEMA_DEFAULTS.members["zeroByte"], self.zero_byte) - serializer.write_short(_SCHEMA_DEFAULTS.members["zeroShort"], self.zero_short) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["zeroInteger"], self.zero_integer - ) - serializer.write_long(_SCHEMA_DEFAULTS.members["zeroLong"], self.zero_long) - serializer.write_float(_SCHEMA_DEFAULTS.members["zeroFloat"], self.zero_float) - serializer.write_double( - _SCHEMA_DEFAULTS.members["zeroDouble"], self.zero_double - ) + members = hydrate(_SCHEMA_DEFAULTS).members_by_index + serializer.write_string(members[0], self.default_string) + serializer.write_boolean(members[1], self.default_boolean) + _serialize_test_string_list(serializer, members[2], self.default_list) + serializer.write_document(members[3], self.default_document_map) + serializer.write_document(members[4], self.default_document_string) + serializer.write_document(members[5], self.default_document_boolean) + serializer.write_document(members[6], self.default_document_list) + serializer.write_document(members[7], self.default_null_document) + serializer.write_timestamp(members[8], self.default_timestamp) + serializer.write_blob(members[9], self.default_blob) + serializer.write_byte(members[10], self.default_byte) + serializer.write_short(members[11], self.default_short) + serializer.write_integer(members[12], self.default_integer) + serializer.write_long(members[13], self.default_long) + serializer.write_float(members[14], self.default_float) + serializer.write_double(members[15], self.default_double) + _serialize_test_string_map(serializer, members[16], self.default_map) + serializer.write_string(members[17], self.default_enum) + serializer.write_integer(members[18], self.default_int_enum) + serializer.write_string(members[19], self.empty_string) + serializer.write_boolean(members[20], self.false_boolean) + serializer.write_blob(members[21], self.empty_blob) + serializer.write_byte(members[22], self.zero_byte) + serializer.write_short(members[23], self.zero_short) + serializer.write_integer(members[24], self.zero_integer) + serializer.write_long(members[25], self.zero_long) + serializer.write_float(members[26], self.zero_float) + serializer.write_double(members[27], self.zero_double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -515,153 +457,105 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DEFAULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["default_string"] = de.read_string( - _SCHEMA_DEFAULTS.members["defaultString"] - ) + kwargs["default_string"] = de.read_string(members[0]) case 1: - kwargs["default_boolean"] = de.read_boolean( - _SCHEMA_DEFAULTS.members["defaultBoolean"] - ) + kwargs["default_boolean"] = de.read_boolean(members[1]) case 2: kwargs["default_list"] = _deserialize_test_string_list( - de, _SCHEMA_DEFAULTS.members["defaultList"] + de, members[2] ) case 3: - kwargs["default_document_map"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentMap"] - ) + kwargs["default_document_map"] = de.read_document(members[3]) case 4: - kwargs["default_document_string"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentString"] - ) + kwargs["default_document_string"] = de.read_document(members[4]) case 5: - kwargs["default_document_boolean"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentBoolean"] - ) + kwargs["default_document_boolean"] = de.read_document(members[5]) case 6: - kwargs["default_document_list"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentList"] - ) + kwargs["default_document_list"] = de.read_document(members[6]) case 7: - kwargs["default_null_document"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultNullDocument"] - ) + kwargs["default_null_document"] = de.read_document(members[7]) case 8: - kwargs["default_timestamp"] = de.read_timestamp( - _SCHEMA_DEFAULTS.members["defaultTimestamp"] - ) + kwargs["default_timestamp"] = de.read_timestamp(members[8]) case 9: - kwargs["default_blob"] = de.read_blob( - _SCHEMA_DEFAULTS.members["defaultBlob"] - ) + kwargs["default_blob"] = de.read_blob(members[9]) case 10: - kwargs["default_byte"] = de.read_byte( - _SCHEMA_DEFAULTS.members["defaultByte"] - ) + kwargs["default_byte"] = de.read_byte(members[10]) case 11: - kwargs["default_short"] = de.read_short( - _SCHEMA_DEFAULTS.members["defaultShort"] - ) + kwargs["default_short"] = de.read_short(members[11]) case 12: - kwargs["default_integer"] = de.read_integer( - _SCHEMA_DEFAULTS.members["defaultInteger"] - ) + kwargs["default_integer"] = de.read_integer(members[12]) case 13: - kwargs["default_long"] = de.read_long( - _SCHEMA_DEFAULTS.members["defaultLong"] - ) + kwargs["default_long"] = de.read_long(members[13]) case 14: - kwargs["default_float"] = de.read_float( - _SCHEMA_DEFAULTS.members["defaultFloat"] - ) + kwargs["default_float"] = de.read_float(members[14]) case 15: - kwargs["default_double"] = de.read_double( - _SCHEMA_DEFAULTS.members["defaultDouble"] - ) + kwargs["default_double"] = de.read_double(members[15]) case 16: kwargs["default_map"] = _deserialize_test_string_map( - de, _SCHEMA_DEFAULTS.members["defaultMap"] + de, members[16] ) case 17: - kwargs["default_enum"] = TestEnum( - de.read_string(_SCHEMA_DEFAULTS.members["defaultEnum"]) - ) + kwargs["default_enum"] = TestEnum(de.read_string(members[17])) case 18: kwargs["default_int_enum"] = TestIntEnum( - de.read_integer(_SCHEMA_DEFAULTS.members["defaultIntEnum"]) + de.read_integer(members[18]) ) case 19: - kwargs["empty_string"] = de.read_string( - _SCHEMA_DEFAULTS.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[19]) case 20: - kwargs["false_boolean"] = de.read_boolean( - _SCHEMA_DEFAULTS.members["falseBoolean"] - ) + kwargs["false_boolean"] = de.read_boolean(members[20]) case 21: - kwargs["empty_blob"] = de.read_blob( - _SCHEMA_DEFAULTS.members["emptyBlob"] - ) + kwargs["empty_blob"] = de.read_blob(members[21]) case 22: - kwargs["zero_byte"] = de.read_byte( - _SCHEMA_DEFAULTS.members["zeroByte"] - ) + kwargs["zero_byte"] = de.read_byte(members[22]) case 23: - kwargs["zero_short"] = de.read_short( - _SCHEMA_DEFAULTS.members["zeroShort"] - ) + kwargs["zero_short"] = de.read_short(members[23]) case 24: - kwargs["zero_integer"] = de.read_integer( - _SCHEMA_DEFAULTS.members["zeroInteger"] - ) + kwargs["zero_integer"] = de.read_integer(members[24]) case 25: - kwargs["zero_long"] = de.read_long( - _SCHEMA_DEFAULTS.members["zeroLong"] - ) + kwargs["zero_long"] = de.read_long(members[25]) case 26: - kwargs["zero_float"] = de.read_float( - _SCHEMA_DEFAULTS.members["zeroFloat"] - ) + kwargs["zero_float"] = de.read_float(members[26]) case 27: - kwargs["zero_double"] = de.read_double( - _SCHEMA_DEFAULTS.members["zeroDouble"] - ) + kwargs["zero_double"] = de.read_double(members[27]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DEFAULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -672,10 +566,11 @@ class Farewell: phrase: str = "bye" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FAREWELL, self) + serializer.write_struct(hydrate(_SCHEMA_FAREWELL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_FAREWELL.members["phrase"], self.phrase) + members = hydrate(_SCHEMA_FAREWELL).members_by_index + serializer.write_string(members[0], self.phrase) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -684,18 +579,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FAREWELL) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["phrase"] = de.read_string( - _SCHEMA_FAREWELL.members["phrase"] - ) + kwargs["phrase"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FAREWELL, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -710,15 +605,16 @@ class Dialog: farewell: Farewell | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DIALOG, self) + serializer.write_struct(hydrate(_SCHEMA_DIALOG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DIALOG).members_by_index if self.language is not None: - serializer.write_string(_SCHEMA_DIALOG.members["language"], self.language) + serializer.write_string(members[0], self.language) - serializer.write_string(_SCHEMA_DIALOG.members["greeting"], self.greeting) + serializer.write_string(members[1], self.greeting) if self.farewell is not None: - serializer.write_struct(_SCHEMA_DIALOG.members["farewell"], self.farewell) + serializer.write_struct(members[2], self.farewell) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -727,26 +623,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DIALOG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["language"] = de.read_string( - _SCHEMA_DIALOG.members["language"] - ) + kwargs["language"] = de.read_string(members[0]) case 1: - kwargs["greeting"] = de.read_string( - _SCHEMA_DIALOG.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[1]) case 2: kwargs["farewell"] = Farewell.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DIALOG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @classmethod @@ -757,7 +651,7 @@ def _smithy_default(cls) -> Self: def _serialize_dialog_list( serializer: ShapeSerializer, schema: Schema, value: list[Dialog] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -783,7 +677,7 @@ def _serialize_dialog_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, Dialog] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -792,7 +686,7 @@ def _deserialize_dialog_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, Dialog]: result: dict[str, Dialog] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -810,7 +704,9 @@ class EmptyInputAndEmptyOutputInput: """Dataclass for EmptyInputAndEmptyOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -822,15 +718,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -849,7 +744,9 @@ class EmptyInputAndEmptyOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -861,27 +758,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_INPUT_AND_EMPTY_OUTPUT = APIOperation( input=EmptyInputAndEmptyOutputInput, output=EmptyInputAndEmptyOutputOutput, - schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, - input_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, - output_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + static_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -890,7 +783,7 @@ class EndpointOperationInput: """Dataclass for EndpointOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -902,13 +795,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -927,7 +821,7 @@ class EndpointOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -939,25 +833,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_OPERATION = APIOperation( input=EndpointOperationInput, output=EndpointOperationOutput, - schema=_SCHEMA_ENDPOINT_OPERATION, - input_schema=_SCHEMA_ENDPOINT_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -968,14 +860,16 @@ class EndpointWithHostLabelOperationInput: label: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT + ).members_by_index if self.label is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members["label"], - self.label, - ) + serializer.write_string(members[0], self.label) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -984,22 +878,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["label"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members[ - "label" - ] - ) + kwargs["label"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1018,7 +908,9 @@ class EndpointWithHostLabelOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1030,27 +922,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_OPERATION = APIOperation( input=EndpointWithHostLabelOperationInput, output=EndpointWithHostLabelOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1064,7 +952,7 @@ class FooError(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FOO_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_FOO_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1076,13 +964,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FOO_ERROR) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FOO_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1093,13 +982,12 @@ class GreetingWithErrorsInput: greeting: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_INPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1108,18 +996,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_INPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1140,13 +1028,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1155,20 +1042,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1179,13 +1064,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1194,27 +1078,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.json10#InvalidGreeting"): InvalidGreeting, @@ -1223,7 +1105,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_INVALID_GREETING, _SCHEMA_COMPLEX_ERROR, _SCHEMA_FOO_ERROR], ) @@ -1232,7 +1113,7 @@ class HostWithPathOperationInput: """Dataclass for HostWithPathOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1244,15 +1125,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1271,7 +1151,7 @@ class HostWithPathOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1283,27 +1163,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HOST_WITH_PATH_OPERATION = APIOperation( input=HostWithPathOperationInput, output=HostWithPathOperationOutput, - schema=_SCHEMA_HOST_WITH_PATH_OPERATION, - input_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, - output_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, + static_schema=_SCHEMA_HOST_WITH_PATH_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1324,7 +1200,7 @@ class IntegerEnum(UnknownEnumMixin, IntEnum): def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1334,7 +1210,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1351,7 +1227,7 @@ def _serialize_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -1360,7 +1236,7 @@ def _deserialize_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -1380,11 +1256,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1393,16 +1270,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1411,16 +1290,16 @@ class MyUnionStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MY_UNION.members["stringValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_MY_UNION.members["stringValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -1428,16 +1307,16 @@ class MyUnionBooleanValue: value: bool def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_boolean(_SCHEMA_MY_UNION.members["booleanValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_boolean(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_boolean(_SCHEMA_MY_UNION.members["booleanValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_boolean(members[1])) @dataclass @@ -1445,16 +1324,16 @@ class MyUnionNumberValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer(_SCHEMA_MY_UNION.members["numberValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_integer(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_integer(_SCHEMA_MY_UNION.members["numberValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_integer(members[2])) @dataclass @@ -1462,14 +1341,16 @@ class MyUnionBlobValue: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_MY_UNION.members["blobValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_blob(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_blob(_SCHEMA_MY_UNION.members["blobValue"])) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_blob(members[3])) @dataclass @@ -1477,20 +1358,16 @@ class MyUnionTimestampValue: value: datetime def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_timestamp( - _SCHEMA_MY_UNION.members["timestampValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_timestamp(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_timestamp( - _SCHEMA_MY_UNION.members["timestampValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_timestamp(members[4])) @dataclass @@ -1498,18 +1375,16 @@ class MyUnionEnumValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MY_UNION.members["enumValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_string(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=FooEnum( - deserializer.read_string(_SCHEMA_MY_UNION.members["enumValue"]) - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=FooEnum(deserializer.read_string(members[5]))) @dataclass @@ -1517,18 +1392,16 @@ class MyUnionIntEnumValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer(_SCHEMA_MY_UNION.members["intEnumValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_integer(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=IntegerEnum( - deserializer.read_integer(_SCHEMA_MY_UNION.members["intEnumValue"]) - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=IntegerEnum(deserializer.read_integer(members[6]))) @dataclass @@ -1536,20 +1409,16 @@ class MyUnionListValue: value: list[str] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_string_list( - serializer, _SCHEMA_MY_UNION.members["listValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + _serialize_string_list(serializer, members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_string_list( - deserializer, _SCHEMA_MY_UNION.members["listValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=_deserialize_string_list(deserializer, members[7])) @dataclass @@ -1557,20 +1426,16 @@ class MyUnionMapValue: value: dict[str, str] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_string_map( - serializer, _SCHEMA_MY_UNION.members["mapValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + _serialize_string_map(serializer, members[8], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_string_map( - deserializer, _SCHEMA_MY_UNION.members["mapValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=_deserialize_string_map(deserializer, members[8])) @dataclass @@ -1578,10 +1443,11 @@ class MyUnionStructureValue: value: GreetingStruct def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION.members["structureValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_struct(members[9], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1633,7 +1499,7 @@ class _MyUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> MyUnion: self._result = None - deserializer.read_struct(_SCHEMA_MY_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_MY_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -1693,13 +1559,12 @@ class JsonUnionsInput: """A union with a representative set of types for members.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_UNIONS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_UNIONS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_UNIONS_INPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_JSON_UNIONS_INPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1708,16 +1573,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_UNIONS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _MyUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_UNIONS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1739,13 +1606,12 @@ class JsonUnionsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_UNIONS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_UNIONS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_UNIONS_OUTPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_JSON_UNIONS_OUTPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1754,28 +1620,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_UNIONS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _MyUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_UNIONS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_UNIONS = APIOperation( input=JsonUnionsInput, output=JsonUnionsOutput, - schema=_SCHEMA_JSON_UNIONS, - input_schema=_SCHEMA_JSON_UNIONS_INPUT, - output_schema=_SCHEMA_JSON_UNIONS_OUTPUT, + static_schema=_SCHEMA_JSON_UNIONS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1784,7 +1649,7 @@ class NoInputAndNoOutputInput: """Dataclass for NoInputAndNoOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1796,15 +1661,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1823,7 +1687,7 @@ class NoInputAndNoOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1835,27 +1699,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_NO_OUTPUT = APIOperation( input=NoInputAndNoOutputInput, output=NoInputAndNoOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1864,7 +1724,7 @@ class NoInputAndOutputInput: """Dataclass for NoInputAndOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1876,13 +1736,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1901,7 +1762,7 @@ class NoInputAndOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1913,25 +1774,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_OUTPUT = APIOperation( input=NoInputAndOutputInput, output=NoInputAndOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1948,31 +1807,21 @@ class OperationWithDefaultsInput: other_top_level_default: int = 0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT).members_by_index if self.defaults is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["defaults"], self.defaults - ) + serializer.write_struct(members[0], self.defaults) if self.client_optional_defaults is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["clientOptionalDefaults"], - self.client_optional_defaults, - ) + serializer.write_struct(members[1], self.client_optional_defaults) if self.top_level_default is not None: - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["topLevelDefault"], - self.top_level_default, - ) + serializer.write_string(members[2], self.top_level_default) if self.other_top_level_default is not None: - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["otherTopLevelDefault"], - self.other_top_level_default, - ) + serializer.write_integer(members[3], self.other_top_level_default) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1981,9 +1830,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["defaults"] = Defaults.deserialize(de) @@ -1993,23 +1844,15 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case 2: - kwargs["top_level_default"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["topLevelDefault"] - ) + kwargs["top_level_default"] = de.read_string(members[2]) case 3: - kwargs["other_top_level_default"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members[ - "otherTopLevelDefault" - ] - ) + kwargs["other_top_level_default"] = de.read_integer(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2084,118 +1927,38 @@ class OperationWithDefaultsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultString"], - self.default_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBoolean"], - self.default_boolean, - ) - _serialize_test_string_list( - serializer, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultList"], - self.default_list, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentMap"], - self.default_document_map, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentString"], - self.default_document_string, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentBoolean"], - self.default_document_boolean, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentList"], - self.default_document_list, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultNullDocument"], - self.default_null_document, - ) - serializer.write_timestamp( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultTimestamp"], - self.default_timestamp, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBlob"], - self.default_blob, - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultByte"], - self.default_byte, - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultShort"], - self.default_short, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultInteger"], - self.default_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultLong"], - self.default_long, - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultFloat"], - self.default_float, - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDouble"], - self.default_double, - ) - _serialize_test_string_map( - serializer, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultMap"], - self.default_map, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultEnum"], - self.default_enum, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultIntEnum"], - self.default_int_enum, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyString"], - self.empty_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["falseBoolean"], - self.false_boolean, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyBlob"], self.empty_blob - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroByte"], self.zero_byte - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroShort"], self.zero_short - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroInteger"], - self.zero_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroLong"], self.zero_long - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroFloat"], self.zero_float - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroDouble"], - self.zero_double, - ) + members = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT).members_by_index + serializer.write_string(members[0], self.default_string) + serializer.write_boolean(members[1], self.default_boolean) + _serialize_test_string_list(serializer, members[2], self.default_list) + serializer.write_document(members[3], self.default_document_map) + serializer.write_document(members[4], self.default_document_string) + serializer.write_document(members[5], self.default_document_boolean) + serializer.write_document(members[6], self.default_document_list) + serializer.write_document(members[7], self.default_null_document) + serializer.write_timestamp(members[8], self.default_timestamp) + serializer.write_blob(members[9], self.default_blob) + serializer.write_byte(members[10], self.default_byte) + serializer.write_short(members[11], self.default_short) + serializer.write_integer(members[12], self.default_integer) + serializer.write_long(members[13], self.default_long) + serializer.write_float(members[14], self.default_float) + serializer.write_double(members[15], self.default_double) + _serialize_test_string_map(serializer, members[16], self.default_map) + serializer.write_string(members[17], self.default_enum) + serializer.write_integer(members[18], self.default_int_enum) + serializer.write_string(members[19], self.empty_string) + serializer.write_boolean(members[20], self.false_boolean) + serializer.write_blob(members[21], self.empty_blob) + serializer.write_byte(members[22], self.zero_byte) + serializer.write_short(members[23], self.zero_short) + serializer.write_integer(members[24], self.zero_integer) + serializer.write_long(members[25], self.zero_long) + serializer.write_float(members[26], self.zero_float) + serializer.write_double(members[27], self.zero_double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2204,188 +1967,114 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["default_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultString"] - ) + kwargs["default_string"] = de.read_string(members[0]) case 1: - kwargs["default_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBoolean"] - ) + kwargs["default_boolean"] = de.read_boolean(members[1]) case 2: kwargs["default_list"] = _deserialize_test_string_list( - de, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultList"], + de, members[2] ) case 3: - kwargs["default_document_map"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentMap" - ] - ) + kwargs["default_document_map"] = de.read_document(members[3]) case 4: - kwargs["default_document_string"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentString" - ] - ) + kwargs["default_document_string"] = de.read_document(members[4]) case 5: - kwargs["default_document_boolean"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentBoolean" - ] - ) + kwargs["default_document_boolean"] = de.read_document(members[5]) case 6: - kwargs["default_document_list"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentList" - ] - ) + kwargs["default_document_list"] = de.read_document(members[6]) case 7: - kwargs["default_null_document"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultNullDocument" - ] - ) + kwargs["default_null_document"] = de.read_document(members[7]) case 8: - kwargs["default_timestamp"] = de.read_timestamp( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultTimestamp" - ] - ) + kwargs["default_timestamp"] = de.read_timestamp(members[8]) case 9: - kwargs["default_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBlob"] - ) + kwargs["default_blob"] = de.read_blob(members[9]) case 10: - kwargs["default_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultByte"] - ) + kwargs["default_byte"] = de.read_byte(members[10]) case 11: - kwargs["default_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultShort"] - ) + kwargs["default_short"] = de.read_short(members[11]) case 12: - kwargs["default_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultInteger"] - ) + kwargs["default_integer"] = de.read_integer(members[12]) case 13: - kwargs["default_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultLong"] - ) + kwargs["default_long"] = de.read_long(members[13]) case 14: - kwargs["default_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultFloat"] - ) + kwargs["default_float"] = de.read_float(members[14]) case 15: - kwargs["default_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDouble"] - ) + kwargs["default_double"] = de.read_double(members[15]) case 16: kwargs["default_map"] = _deserialize_test_string_map( - de, _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultMap"] + de, members[16] ) case 17: - kwargs["default_enum"] = TestEnum( - de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultEnum" - ] - ) - ) + kwargs["default_enum"] = TestEnum(de.read_string(members[17])) case 18: kwargs["default_int_enum"] = TestIntEnum( - de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultIntEnum" - ] - ) + de.read_integer(members[18]) ) case 19: - kwargs["empty_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[19]) case 20: - kwargs["false_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["falseBoolean"] - ) + kwargs["false_boolean"] = de.read_boolean(members[20]) case 21: - kwargs["empty_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyBlob"] - ) + kwargs["empty_blob"] = de.read_blob(members[21]) case 22: - kwargs["zero_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroByte"] - ) + kwargs["zero_byte"] = de.read_byte(members[22]) case 23: - kwargs["zero_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroShort"] - ) + kwargs["zero_short"] = de.read_short(members[23]) case 24: - kwargs["zero_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroInteger"] - ) + kwargs["zero_integer"] = de.read_integer(members[24]) case 25: - kwargs["zero_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroLong"] - ) + kwargs["zero_long"] = de.read_long(members[25]) case 26: - kwargs["zero_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroFloat"] - ) + kwargs["zero_float"] = de.read_float(members[26]) case 27: - kwargs["zero_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroDouble"] - ) + kwargs["zero_double"] = de.read_double(members[27]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OPERATION_WITH_DEFAULTS = APIOperation( input=OperationWithDefaultsInput, output=OperationWithDefaultsOutput, - schema=_SCHEMA_OPERATION_WITH_DEFAULTS, - input_schema=_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_DEFAULTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2400,16 +2089,13 @@ class TopLevel: dialog_map: dict[str, Dialog] = field(default_factory=dict[str, Dialog]) def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOP_LEVEL, self) + serializer.write_struct(hydrate(_SCHEMA_TOP_LEVEL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOP_LEVEL.members["dialog"], self.dialog) - _serialize_dialog_list( - serializer, _SCHEMA_TOP_LEVEL.members["dialogList"], self.dialog_list - ) - _serialize_dialog_map( - serializer, _SCHEMA_TOP_LEVEL.members["dialogMap"], self.dialog_map - ) + members = hydrate(_SCHEMA_TOP_LEVEL).members_by_index + serializer.write_struct(members[0], self.dialog) + _serialize_dialog_list(serializer, members[1], self.dialog_list) + _serialize_dialog_map(serializer, members[2], self.dialog_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2418,26 +2104,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOP_LEVEL) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dialog"] = Dialog.deserialize(de) case 1: - kwargs["dialog_list"] = _deserialize_dialog_list( - de, _SCHEMA_TOP_LEVEL.members["dialogList"] - ) + kwargs["dialog_list"] = _deserialize_dialog_list(de, members[1]) case 2: - kwargs["dialog_map"] = _deserialize_dialog_map( - de, _SCHEMA_TOP_LEVEL.members["dialogMap"] - ) + kwargs["dialog_map"] = _deserialize_dialog_map(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOP_LEVEL, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "dialog" not in kwargs: kwargs["dialog"] = Dialog._smithy_default() return kwargs @@ -2450,14 +2134,16 @@ class OperationWithNestedStructureInput: top_level: TopLevel | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT + ).members_by_index if self.top_level is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT.members["topLevel"], - self.top_level, - ) + serializer.write_struct(members[0], self.top_level) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2466,18 +2152,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["top_level"] = TopLevel.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2502,24 +2188,18 @@ class OperationWithNestedStructureOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members["dialog"], - self.dialog, - ) - _serialize_dialog_list( - serializer, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members["dialogList"], - self.dialog_list, - ) - _serialize_dialog_map( - serializer, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members["dialogMap"], - self.dialog_map, + hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT + ).members_by_index + serializer.write_struct(members[0], self.dialog) + _serialize_dialog_list(serializer, members[1], self.dialog_list) + _serialize_dialog_map(serializer, members[2], self.dialog_map) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls(**cls.deserialize_kwargs(deserializer)) @@ -2527,34 +2207,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dialog"] = Dialog.deserialize(de) case 1: - kwargs["dialog_list"] = _deserialize_dialog_list( - de, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members[ - "dialogList" - ], - ) + kwargs["dialog_list"] = _deserialize_dialog_list(de, members[1]) case 2: - kwargs["dialog_map"] = _deserialize_dialog_map( - de, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members[ - "dialogMap" - ], - ) + kwargs["dialog_map"] = _deserialize_dialog_map(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "dialog" not in kwargs: kwargs["dialog"] = Dialog._smithy_default() return kwargs @@ -2563,12 +2233,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: OPERATION_WITH_NESTED_STRUCTURE = APIOperation( input=OperationWithNestedStructureInput, output=OperationWithNestedStructureOutput, - schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE, - input_schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2577,7 +2244,9 @@ class OperationWithRequiredMembersInput: """Dataclass for OperationWithRequiredMembersInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2589,22 +2258,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_required_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2614,7 +2282,7 @@ def _deserialize_required_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2631,7 +2299,7 @@ def _serialize_required_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2640,7 +2308,7 @@ def _deserialize_required_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2692,59 +2360,26 @@ class OperationWithRequiredMembersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredString"], - self.required_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredBoolean"], - self.required_boolean, - ) - _serialize_required_string_list( - serializer, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredList"], - self.required_list, - ) - serializer.write_timestamp( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredTimestamp"], - self.required_timestamp, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredBlob"], - self.required_blob, - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredByte"], - self.required_byte, - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredShort"], - self.required_short, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredInteger"], - self.required_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredLong"], - self.required_long, - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredFloat"], - self.required_float, - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredDouble"], - self.required_double, - ) - _serialize_required_string_map( - serializer, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members["requiredMap"], - self.required_map, - ) + members = hydrate( + _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT + ).members_by_index + serializer.write_string(members[0], self.required_string) + serializer.write_boolean(members[1], self.required_boolean) + _serialize_required_string_list(serializer, members[2], self.required_list) + serializer.write_timestamp(members[3], self.required_timestamp) + serializer.write_blob(members[4], self.required_blob) + serializer.write_byte(members[5], self.required_byte) + serializer.write_short(members[6], self.required_short) + serializer.write_integer(members[7], self.required_integer) + serializer.write_long(members[8], self.required_long) + serializer.write_float(members[9], self.required_float) + serializer.write_double(members[10], self.required_double) + _serialize_required_string_map(serializer, members[11], self.required_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2753,101 +2388,55 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["required_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredString" - ] - ) + kwargs["required_string"] = de.read_string(members[0]) case 1: - kwargs["required_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredBoolean" - ] - ) + kwargs["required_boolean"] = de.read_boolean(members[1]) case 2: kwargs["required_list"] = _deserialize_required_string_list( - de, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredList" - ], + de, members[2] ) case 3: - kwargs["required_timestamp"] = de.read_timestamp( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredTimestamp" - ] - ) + kwargs["required_timestamp"] = de.read_timestamp(members[3]) case 4: - kwargs["required_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredBlob" - ] - ) + kwargs["required_blob"] = de.read_blob(members[4]) case 5: - kwargs["required_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredByte" - ] - ) + kwargs["required_byte"] = de.read_byte(members[5]) case 6: - kwargs["required_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredShort" - ] - ) + kwargs["required_short"] = de.read_short(members[6]) case 7: - kwargs["required_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredInteger" - ] - ) + kwargs["required_integer"] = de.read_integer(members[7]) case 8: - kwargs["required_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredLong" - ] - ) + kwargs["required_long"] = de.read_long(members[8]) case 9: - kwargs["required_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredFloat" - ] - ) + kwargs["required_float"] = de.read_float(members[9]) case 10: - kwargs["required_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredDouble" - ] - ) + kwargs["required_double"] = de.read_double(members[10]) case 11: kwargs["required_map"] = _deserialize_required_string_map( - de, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT.members[ - "requiredMap" - ], + de, members[11] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "required_string" not in kwargs: kwargs["required_string"] = "" if "required_boolean" not in kwargs: @@ -2878,12 +2467,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: OPERATION_WITH_REQUIRED_MEMBERS = APIOperation( input=OperationWithRequiredMembersInput, output=OperationWithRequiredMembersOutput, - schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS, - input_schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2893,7 +2479,7 @@ class OperationWithRequiredMembersWithDefaultsInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT, self + hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -2906,16 +2492,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2974,96 +2558,27 @@ class OperationWithRequiredMembersWithDefaultsOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT, self + hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredString" - ], - self.required_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredBoolean" - ], - self.required_boolean, - ) - _serialize_required_string_list( - serializer, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredList" - ], - self.required_list, - ) - serializer.write_timestamp( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredTimestamp" - ], - self.required_timestamp, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredBlob" - ], - self.required_blob, - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredByte" - ], - self.required_byte, - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredShort" - ], - self.required_short, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredInteger" - ], - self.required_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredLong" - ], - self.required_long, - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredFloat" - ], - self.required_float, - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredDouble" - ], - self.required_double, - ) - _serialize_required_string_map( - serializer, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredMap" - ], - self.required_map, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredEnum" - ], - self.required_enum, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredIntEnum" - ], - self.required_int_enum, - ) + members = hydrate( + _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT + ).members_by_index + serializer.write_string(members[0], self.required_string) + serializer.write_boolean(members[1], self.required_boolean) + _serialize_required_string_list(serializer, members[2], self.required_list) + serializer.write_timestamp(members[3], self.required_timestamp) + serializer.write_blob(members[4], self.required_blob) + serializer.write_byte(members[5], self.required_byte) + serializer.write_short(members[6], self.required_short) + serializer.write_integer(members[7], self.required_integer) + serializer.write_long(members[8], self.required_long) + serializer.write_float(members[9], self.required_float) + serializer.write_double(members[10], self.required_double) + _serialize_required_string_map(serializer, members[11], self.required_map) + serializer.write_string(members[12], self.required_enum) + serializer.write_integer(members[13], self.required_int_enum) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3072,132 +2587,72 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["required_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredString" - ] - ) + kwargs["required_string"] = de.read_string(members[0]) case 1: - kwargs["required_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredBoolean" - ] - ) + kwargs["required_boolean"] = de.read_boolean(members[1]) case 2: kwargs["required_list"] = _deserialize_required_string_list( - de, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredList" - ], + de, members[2] ) case 3: - kwargs["required_timestamp"] = de.read_timestamp( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredTimestamp" - ] - ) + kwargs["required_timestamp"] = de.read_timestamp(members[3]) case 4: - kwargs["required_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredBlob" - ] - ) + kwargs["required_blob"] = de.read_blob(members[4]) case 5: - kwargs["required_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredByte" - ] - ) + kwargs["required_byte"] = de.read_byte(members[5]) case 6: - kwargs["required_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredShort" - ] - ) + kwargs["required_short"] = de.read_short(members[6]) case 7: - kwargs["required_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredInteger" - ] - ) + kwargs["required_integer"] = de.read_integer(members[7]) case 8: - kwargs["required_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredLong" - ] - ) + kwargs["required_long"] = de.read_long(members[8]) case 9: - kwargs["required_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredFloat" - ] - ) + kwargs["required_float"] = de.read_float(members[9]) case 10: - kwargs["required_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredDouble" - ] - ) + kwargs["required_double"] = de.read_double(members[10]) case 11: kwargs["required_map"] = _deserialize_required_string_map( - de, - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredMap" - ], + de, members[11] ) case 12: - kwargs["required_enum"] = RequiredEnum( - de.read_string( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredEnum" - ] - ) - ) + kwargs["required_enum"] = RequiredEnum(de.read_string(members[12])) case 13: kwargs["required_int_enum"] = RequiredIntEnum( - de.read_integer( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT.members[ - "requiredIntEnum" - ] - ) + de.read_integer(members[13]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS = APIOperation( input=OperationWithRequiredMembersWithDefaultsInput, output=OperationWithRequiredMembersWithDefaultsOutput, - schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS, - input_schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3210,19 +2665,15 @@ class PutWithContentEncodingInput: data: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT).members_by_index if self.encoding is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"], - self.encoding, - ) + serializer.write_string(members[0], self.encoding) if self.data is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"], self.data - ) + serializer.write_string(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3231,25 +2682,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["encoding"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"] - ) + kwargs["encoding"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"] - ) + kwargs["data"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3268,7 +2715,7 @@ class PutWithContentEncodingOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3280,27 +2727,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_WITH_CONTENT_ENCODING = APIOperation( input=PutWithContentEncodingInput, output=PutWithContentEncodingOutput, - schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, - input_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, - output_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, + static_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3309,7 +2752,9 @@ class QueryIncompatibleOperationInput: """Dataclass for QueryIncompatibleOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3321,15 +2766,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_INCOMPATIBLE_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3348,7 +2792,9 @@ class QueryIncompatibleOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3360,27 +2806,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_INCOMPATIBLE_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_INCOMPATIBLE_OPERATION = APIOperation( input=QueryIncompatibleOperationInput, output=QueryIncompatibleOperationOutput, - schema=_SCHEMA_QUERY_INCOMPATIBLE_OPERATION, - input_schema=_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_INPUT, - output_schema=_SCHEMA_QUERY_INCOMPATIBLE_OPERATION_OUTPUT, + static_schema=_SCHEMA_QUERY_INCOMPATIBLE_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3393,20 +2835,15 @@ class SimpleScalarPropertiesInput: double_value: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT).members_by_index if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[0], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[1], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3415,25 +2852,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[0]) case 1: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3456,20 +2889,15 @@ class SimpleScalarPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT).members_by_index if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[0], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[1], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3478,35 +2906,28 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[0]) case 1: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_PROPERTIES = APIOperation( input=SimpleScalarPropertiesInput, output=SimpleScalarPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) diff --git a/codegen-output/aws-json-1-1/pyproject.toml b/codegen-output/aws-json-1-1/pyproject.toml index a9b718abf..619fac867 100644 --- a/codegen-output/aws-json-1-1/pyproject.toml +++ b/codegen-output/aws-json-1-1/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py b/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py index cfce2e863..7b5c1c7df 100644 --- a/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py +++ b/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py @@ -2,1186 +2,1096 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - DOUBLE, - FLOAT, - INTEGER, - LONG, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("aws.protocoltests.json#ComplexNestedErrorData"), - members={ - "Foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="Fooooo")], - } - }, -) - -COMPLEX_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.json#ComplexError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, -) - -CONTENT_TYPE_PARAMETERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#ContentTypeParametersInput"), - members={"value": {"target": INTEGER}}, -) - -CONTENT_TYPE_PARAMETERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#ContentTypeParametersOutput") -) - -CONTENT_TYPE_PARAMETERS = Schema( - id=ShapeID("aws.protocoltests.json#ContentTypeParameters"), - shape_type=ShapeType.OPERATION, -) - -DATETIME_OFFSETS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#DatetimeOffsetsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.shared#DateTime"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], -) - -DATETIME_OFFSETS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#DatetimeOffsetsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -DATETIME_OFFSETS = Schema( - id=ShapeID("aws.protocoltests.json#DatetimeOffsets"), shape_type=ShapeType.OPERATION -) - -DOCUMENT = Schema( - id=ShapeID("aws.protocoltests.json#Document"), shape_type=ShapeType.DOCUMENT -) - -EMPTY_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#EmptyOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -EMPTY_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#EmptyOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -EMPTY_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#EmptyOperation"), shape_type=ShapeType.OPERATION -) - -EMPTY_STRUCT = Schema.collection(id=ShapeID("aws.protocoltests.json#EmptyStruct")) - -ENDPOINT_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#EndpointOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#EndpointOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#EndpointOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo."}), - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#EndpointWithHostLabelOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#HostLabelInput", - ) - ], - members={ - "label": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#EndpointWithHostLabelOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#EndpointWithHostLabelOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo.{label}."}), - ) - ], -) - -JSON_VALUE = Schema( - id=ShapeID("aws.protocoltests.json#JsonValue"), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#mediaType"), value="application/json")], -) - -LIST_OF_STRINGS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ListOfStrings"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -LIST_OF_LIST_OF_STRINGS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ListOfListOfStrings"), - shape_type=ShapeType.LIST, - members={"member": {"target": LIST_OF_STRINGS}}, -) - -MAP_OF_STRINGS = Schema.collection( - id=ShapeID("aws.protocoltests.json#MapOfStrings"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -LIST_OF_MAPS_OF_STRINGS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ListOfMapsOfStrings"), - shape_type=ShapeType.LIST, - members={"member": {"target": MAP_OF_STRINGS}}, -) - -SIMPLE_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.json#SimpleStruct"), - members={"Value": {"target": STRING}}, -) - -LIST_OF_STRUCTS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ListOfStructs"), - shape_type=ShapeType.LIST, - members={"member": {"target": SIMPLE_STRUCT}}, -) - -MAP_OF_LISTS_OF_STRINGS = Schema.collection( - id=ShapeID("aws.protocoltests.json#MapOfListsOfStrings"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": LIST_OF_STRINGS}}, -) - -MAP_OF_MAP_OF_STRINGS = Schema.collection( - id=ShapeID("aws.protocoltests.json#MapOfMapOfStrings"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": MAP_OF_STRINGS}}, -) - -MAP_OF_STRUCTS = Schema.collection( - id=ShapeID("aws.protocoltests.json#MapOfStructs"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": SIMPLE_STRUCT}}, -) - -STRUCT_WITH_JSON_NAME = Schema.collection( - id=ShapeID("aws.protocoltests.json#StructWithJsonName"), - members={ - "Value": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#jsonName"), value="RenamedMember") - ], - } - }, -) - -ERROR_WITHOUT_MEMBERS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ErrorWithoutMembers"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="server")], -) - -FOO_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.json#FooError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="server")], -) - -FRACTIONAL_SECONDS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#FractionalSecondsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -FRACTIONAL_SECONDS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#FractionalSecondsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -FRACTIONAL_SECONDS = Schema( - id=ShapeID("aws.protocoltests.json#FractionalSeconds"), - shape_type=ShapeType.OPERATION, -) - -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#GreetingWithErrorsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#GreetingWithErrorsOutput"), - members={"greeting": {"target": STRING}}, -) - -INVALID_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.json#InvalidGreeting"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={"Message": {"target": STRING}}, -) - -GREETING_WITH_ERRORS = Schema( - id=ShapeID("aws.protocoltests.json#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, -) -HOST_WITH_PATH_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#HostWithPathOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +n0 = "aws.protocoltests.json" +_CNED = "ComplexNestedErrorData" +_F = "Foo" +_sN = "smithy.api#jsonName" +_Fo = "Fooooo" +_CE = "ComplexError" +_s = "smithy.api#error" +_c = "client" +_TL = "TopLevel" +_N = "Nested" +_CTPI = "ContentTypeParametersInput" +_v = "value" +_CTPO = "ContentTypeParametersOutput" +_CTP = "ContentTypeParameters" +_DOI = "DatetimeOffsetsInput" +_sSI = "smithy.synthetic#originalShapeId" +_sU = "smithy.api#Unit" +n1 = "aws.protocoltests.shared" +_DT = "DateTime" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_DOO = "DatetimeOffsetsOutput" +_d = "datetime" +_DO = "DatetimeOffsets" +_D = "Document" +_EOI = "EmptyOperationInput" +_EOO = "EmptyOperationOutput" +_EO = "EmptyOperation" +_ES = "EmptyStruct" +_EOIn = "EndpointOperationInput" +_EOOn = "EndpointOperationOutput" +_EOn = "EndpointOperation" +_sm = "smithy.api#endpoint" +_EWHLOI = "EndpointWithHostLabelOperationInput" +_aHLI = "aws.protocoltests.json#HostLabelInput" +_l = "label" +_sL = "smithy.api#hostLabel" +_smi = "smithy.api#required" +_EWHLOO = "EndpointWithHostLabelOperationOutput" +_EWHLO = "EndpointWithHostLabelOperation" +_JV = "JsonValue" +_sT = "smithy.api#mediaType" +_a = "application/json" +_LOS = "ListOfStrings" +_m = "member" +_LOLOS = "ListOfListOfStrings" +_MOS = "MapOfStrings" +_k = "key" +_LOMOS = "ListOfMapsOfStrings" +_SS = "SimpleStruct" +_V = "Value" +_LOSi = "ListOfStructs" +_MOLOS = "MapOfListsOfStrings" +_MOMOS = "MapOfMapOfStrings" +_MOSa = "MapOfStructs" +_SWJN = "StructWithJsonName" +_RM = "RenamedMember" +_EWM = "ErrorWithoutMembers" +_se = "server" +_FE = "FooError" +_FSI = "FractionalSecondsInput" +_FSO = "FractionalSecondsOutput" +_FS = "FractionalSeconds" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_g = "greeting" +_IG = "InvalidGreeting" +_M = "Message" +_GWE = "GreetingWithErrors" +_HWPOI = "HostWithPathOperationInput" +_HWPOO = "HostWithPathOperationOutput" +_HWPO = "HostWithPathOperation" +_FEo = "FooEnum" +_FOO = "FOO" +_BAZ = "BAZ" +_BAR = "BAR" +_ONE = "ONE" +_ZERO = "ZERO" +_FEL = "FooEnumList" +_FEM = "FooEnumMap" +_FES = "FooEnumSet" +_JEI = "JsonEnumsInput" +_aJEIO = "aws.protocoltests.json#JsonEnumsInputOutput" +_fE = "fooEnum1" +_fEo = "fooEnum2" +_fEoo = "fooEnum3" +_fEL = "fooEnumList" +_fES = "fooEnumSet" +_fEM = "fooEnumMap" +_JEO = "JsonEnumsOutput" +_JE = "JsonEnums" +_IE = "IntegerEnum" +_A = "A" +_B = "B" +_C = "C" +_IEL = "IntegerEnumList" +_IEM = "IntegerEnumMap" +_IES = "IntegerEnumSet" +_JIEI = "JsonIntEnumsInput" +_aJIEIO = "aws.protocoltests.json#JsonIntEnumsInputOutput" +_iE = "intEnum1" +_iEn = "intEnum2" +_iEnt = "intEnum3" +_iEL = "intEnumList" +_iES = "intEnumSet" +_iEM = "intEnumMap" +_JIEO = "JsonIntEnumsOutput" +_JIE = "JsonIntEnums" +_SL = "StringList" +_SM = "StringMap" +_GS = "GreetingStruct" +_h = "hi" +_MU = "MyUnion" +_sV = "stringValue" +_bV = "booleanValue" +_nV = "numberValue" +_bVl = "blobValue" +_tV = "timestampValue" +_eV = "enumValue" +_lV = "listValue" +_mV = "mapValue" +_sVt = "structureValue" +_JUI = "JsonUnionsInput" +_aUIO = "aws.protocoltests.json#UnionInputOutput" +_co = "contents" +_JUO = "JsonUnionsOutput" +_JU = "JsonUnions" +_NOI = "NullOperationInput" +_aNOIO = "aws.protocoltests.json#NullOperationInputOutput" +_st = "string" +_NOO = "NullOperationOutput" +_NO = "NullOperation" +_OWOIOI = "OperationWithOptionalInputOutputInput" +_OWOIOO = "OperationWithOptionalInputOutputOutput" +_OWOIO = "OperationWithOptionalInputOutput" +_PAGIDI = "PutAndGetInlineDocumentsInput" +_aPAGIDIO = "aws.protocoltests.json#PutAndGetInlineDocumentsInputOutput" +_iD = "inlineDocument" +_PAGIDO = "PutAndGetInlineDocumentsOutput" +_PAGID = "PutAndGetInlineDocuments" +_PWCEI = "PutWithContentEncodingInput" +_e = "encoding" +_sH = "smithy.api#httpHeader" +_CE_ = "Content-Encoding" +_da = "data" +_PWCEO = "PutWithContentEncodingOutput" +_PWCE = "PutWithContentEncoding" +_sC = "smithy.api#requestCompression" +_SSPI = "SimpleScalarPropertiesInput" +_aSSPIO = "aws.protocoltests.json#SimpleScalarPropertiesInputOutput" +_fV = "floatValue" +_dV = "doubleValue" +_SSPO = "SimpleScalarPropertiesOutput" +_SSP = "SimpleScalarProperties" +_SSL = "SparseStringList" +_smit = "smithy.api#sparse" +_SSM = "SparseStringMap" +_SNOI = "SparseNullsOperationInput" +_aSNOIO = "aws.protocoltests.json#SparseNullsOperationInputOutput" +_sSL = "sparseStringList" +_sSM = "sparseStringMap" +_SNOO = "SparseNullsOperationOutput" +_SNO = "SparseNullsOperation" +_KS = "KitchenSink" +_Bl = "Blob" +_Bo = "Boolean" +_Do = "Double" +_Fl = "Float" +_HT = "HttpdateTimestamp" +_hd = "http-date" +_I = "Integer" +_IT = "Iso8601Timestamp" +_LOL = "ListOfLists" +_L = "Long" +_MOM = "MapOfMaps" +_RL = "RecursiveList" +_RMe = "RecursiveMap" +_RS = "RecursiveStruct" +_S = "String" +_T = "Timestamp" +_UT = "UnixTimestamp" +_es = "epoch-seconds" +_LOKS = "ListOfKitchenSinks" +_MOKS = "MapOfKitchenSinks" +_EWMr = "ErrorWithMembers" +_Co = "Code" +_CD = "ComplexData" +_IF = "IntegerField" +_LF = "ListField" +_MF = "MapField" +_SF = "StringField" +_KSOI = "KitchenSinkOperationInput" +_aKS = "aws.protocoltests.json#KitchenSink" +_KSOO = "KitchenSinkOperationOutput" +_KSO = "KitchenSinkOperation" +_JP = "JsonProtocol" +_aw = "aws.auth#sigv4" +_a_ = "aws.protocols#awsJson1_1" +_sB = "smithy.rules#endpointBdd" +_aws = "aws.api#service" + +COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, {_sN: _Fo}),)) + +COMPLEX_ERROR = ( + 18, + n0, + _CE, + {_s: _c}, + (_TL, _N), + ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), +) + +CONTENT_TYPE_PARAMETERS_INPUT = (18, n0, _CTPI, 0, (_v,), ((7, 0),)) + +CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n0, _CTPO, 0) + +CONTENT_TYPE_PARAMETERS = ( + 23, + n0, + _CTP, + 0, + CONTENT_TYPE_PARAMETERS_INPUT, + CONTENT_TYPE_PARAMETERS_OUTPUT, + (), +) + +DATETIME_OFFSETS_INPUT = (18, n0, _DOI, {_sSI: _sU}) + +DATE_TIME = (4, n1, _DT, {_sF: _dt}) + +DATETIME_OFFSETS_OUTPUT = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) + +DATETIME_OFFSETS = (23, n0, _DO, 0, DATETIME_OFFSETS_INPUT, DATETIME_OFFSETS_OUTPUT, ()) + +DOCUMENT = (13, n0, _D, 0) + +EMPTY_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) + +EMPTY_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#HostWithPathOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +EMPTY_OPERATION = (23, n0, _EO, 0, EMPTY_OPERATION_INPUT, EMPTY_OPERATION_OUTPUT, ()) -HOST_WITH_PATH_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#HostWithPathOperation"), - shape_type=ShapeType.OPERATION, -) +EMPTY_STRUCT = (18, n0, _ES, 0) -FOO_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, -) +ENDPOINT_OPERATION_INPUT = (18, n0, _EOIn, {_sSI: _sU}) -FOO_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) +ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOOn, {_sSI: _sU}) -FOO_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": FOO_ENUM}}, +ENDPOINT_OPERATION = ( + 23, + n0, + _EOn, + {_sm: MappingProxyType({"hostPrefix": "foo."})}, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), ) -FOO_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( + 18, + n0, + _EWHLOI, + {_sSI: _aHLI}, + (_l,), + ((3, 257),), ) -JSON_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#JsonEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#JsonEnumsInputOutput", - ) - ], - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, -) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) -JSON_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#JsonEnumsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#JsonEnumsInputOutput", - ) - ], - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, +ENDPOINT_WITH_HOST_LABEL_OPERATION = ( + 23, + n0, + _EWHLO, + {_sm: MappingProxyType({"hostPrefix": "foo.{label}."})}, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), ) -JSON_ENUMS = Schema( - id=ShapeID("aws.protocoltests.json#JsonEnums"), shape_type=ShapeType.OPERATION -) +JSON_VALUE = (3, n0, _JV, {_sT: _a}) -INTEGER_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, -) +LIST_OF_STRINGS = (16, n0, _LOS, 0, (_m,), ((3, 0),)) -INTEGER_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) +LIST_OF_LIST_OF_STRINGS = (16, n0, _LOLOS, 0, (_m,), ((LIST_OF_STRINGS, 0),)) -INTEGER_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER_ENUM}}, -) +MAP_OF_STRINGS = (17, n0, _MOS, 0, (_k, _v), ((3, 0), (3, 0))) -INTEGER_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) +LIST_OF_MAPS_OF_STRINGS = (16, n0, _LOMOS, 0, (_m,), ((MAP_OF_STRINGS, 0),)) -JSON_INT_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#JsonIntEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#JsonIntEnumsInputOutput", - ) - ], - members={ - "intEnum1": {"target": INTEGER_ENUM}, - "intEnum2": {"target": INTEGER_ENUM}, - "intEnum3": {"target": INTEGER_ENUM}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "intEnumSet": {"target": INTEGER_ENUM_SET}, - "intEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -JSON_INT_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#JsonIntEnumsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#JsonIntEnumsInputOutput", - ) - ], - members={ - "intEnum1": {"target": INTEGER_ENUM}, - "intEnum2": {"target": INTEGER_ENUM}, - "intEnum3": {"target": INTEGER_ENUM}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "intEnumSet": {"target": INTEGER_ENUM_SET}, - "intEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -JSON_INT_ENUMS = Schema( - id=ShapeID("aws.protocoltests.json#JsonIntEnums"), shape_type=ShapeType.OPERATION -) - -STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -GREETING_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, -) - -MY_UNION = Schema.collection( - id=ShapeID("aws.protocoltests.json#MyUnion"), - shape_type=ShapeType.UNION, - members={ - "stringValue": {"target": STRING}, - "booleanValue": {"target": BOOLEAN}, - "numberValue": {"target": INTEGER}, - "blobValue": {"target": BLOB}, - "timestampValue": {"target": TIMESTAMP}, - "enumValue": {"target": FOO_ENUM}, - "listValue": {"target": STRING_LIST}, - "mapValue": {"target": STRING_MAP}, - "structureValue": {"target": GREETING_STRUCT}, - }, -) - -JSON_UNIONS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#JsonUnionsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#UnionInputOutput", - ) - ], - members={"contents": {"target": MY_UNION}}, -) - -JSON_UNIONS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#JsonUnionsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#UnionInputOutput", - ) - ], - members={"contents": {"target": MY_UNION}}, -) +SIMPLE_STRUCT = (18, n0, _SS, 0, (_V,), ((3, 0),)) -JSON_UNIONS = Schema( - id=ShapeID("aws.protocoltests.json#JsonUnions"), shape_type=ShapeType.OPERATION -) +LIST_OF_STRUCTS = (16, n0, _LOSi, 0, (_m,), ((SIMPLE_STRUCT, 0),)) -NULL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#NullOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#NullOperationInputOutput", - ) - ], - members={"string": {"target": STRING}}, -) +MAP_OF_LISTS_OF_STRINGS = (17, n0, _MOLOS, 0, (_k, _v), ((3, 0), (LIST_OF_STRINGS, 0))) -NULL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#NullOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#NullOperationInputOutput", - ) - ], - members={"string": {"target": STRING}}, -) +MAP_OF_MAP_OF_STRINGS = (17, n0, _MOMOS, 0, (_k, _v), ((3, 0), (MAP_OF_STRINGS, 0))) -NULL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#NullOperation"), shape_type=ShapeType.OPERATION -) +MAP_OF_STRUCTS = (17, n0, _MOSa, 0, (_k, _v), ((3, 0), (SIMPLE_STRUCT, 0))) -OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#OperationWithOptionalInputOutputInput"), - members={"Value": {"target": STRING}}, -) +STRUCT_WITH_JSON_NAME = (18, n0, _SWJN, 0, (_V,), ((3, {_sN: _RM}),)) -OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#OperationWithOptionalInputOutputOutput"), - members={"Value": {"target": STRING}}, -) +ERROR_WITHOUT_MEMBERS = (18, n0, _EWM, {_s: _se}) -OPERATION_WITH_OPTIONAL_INPUT_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.json#OperationWithOptionalInputOutput"), - shape_type=ShapeType.OPERATION, -) +FOO_ERROR = (18, n0, _FE, {_s: _se}) -PUT_AND_GET_INLINE_DOCUMENTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#PutAndGetInlineDocumentsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#PutAndGetInlineDocumentsInputOutput", - ) - ], - members={"inlineDocument": {"target": DOCUMENT}}, -) +FRACTIONAL_SECONDS_INPUT = (18, n0, _FSI, {_sSI: _sU}) -PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#PutAndGetInlineDocumentsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#PutAndGetInlineDocumentsInputOutput", - ) - ], - members={"inlineDocument": {"target": DOCUMENT}}, -) +FRACTIONAL_SECONDS_OUTPUT = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -PUT_AND_GET_INLINE_DOCUMENTS = Schema( - id=ShapeID("aws.protocoltests.json#PutAndGetInlineDocuments"), - shape_type=ShapeType.OPERATION, +FRACTIONAL_SECONDS = ( + 23, + n0, + _FS, + 0, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#PutWithContentEncodingInput"), - members={ - "encoding": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Encoding") - ], - }, - "data": {"target": STRING}, - }, -) +GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#PutWithContentEncodingOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -PUT_WITH_CONTENT_ENCODING = Schema( - id=ShapeID("aws.protocoltests.json#PutWithContentEncoding"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#requestCompression"), - value=MappingProxyType({"encodings": ("gzip",)}), - ) - ], -) +INVALID_GREETING = (18, n0, _IG, {_s: _c}, (_M,), ((3, 0),)) -SIMPLE_SCALAR_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#SimpleScalarPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#SimpleScalarPropertiesInputOutput", - ) - ], - members={"floatValue": {"target": FLOAT}, "doubleValue": {"target": DOUBLE}}, +GREETING_WITH_ERRORS = ( + 23, + n0, + _GWE, + 0, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR, FOO_ERROR), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#SimpleScalarPropertiesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#SimpleScalarPropertiesInputOutput", - ) - ], - members={"floatValue": {"target": FLOAT}, "doubleValue": {"target": DOUBLE}}, -) +HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) -SIMPLE_SCALAR_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.json#SimpleScalarProperties"), - shape_type=ShapeType.OPERATION, -) +HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) -SPARSE_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#SparseStringList"), - shape_type=ShapeType.LIST, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"member": {"target": STRING}}, +HOST_WITH_PATH_OPERATION = ( + 23, + n0, + _HWPO, + 0, + HOST_WITH_PATH_OPERATION_INPUT, + HOST_WITH_PATH_OPERATION_OUTPUT, + (), ) -SPARSE_STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#SparseStringMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": STRING}}, +FOO_ENUM = ( + 14, + n1, + _FEo, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -SPARSE_NULLS_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#SparseNullsOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#SparseNullsOperationInputOutput", - ) - ], - members={ - "sparseStringList": {"target": SPARSE_STRING_LIST}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - }, -) +FOO_ENUM_LIST = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -SPARSE_NULLS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#SparseNullsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#SparseNullsOperationInputOutput", - ) - ], - members={ - "sparseStringList": {"target": SPARSE_STRING_LIST}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - }, -) +FOO_ENUM_MAP = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -SPARSE_NULLS_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#SparseNullsOperation"), - shape_type=ShapeType.OPERATION, -) +FOO_ENUM_SET = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -KITCHEN_SINK = Schema.collection( - id=ShapeID("aws.protocoltests.json#KitchenSink"), - members={ - "Blob": {"target": BLOB}, - "Boolean": {"target": BOOLEAN}, - "Double": {"target": DOUBLE}, - "EmptyStruct": {"target": EMPTY_STRUCT}, - "Float": {"target": FLOAT}, - "HttpdateTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "Integer": {"target": INTEGER}, - "Iso8601Timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "JsonValue": {"target": JSON_VALUE}, - "ListOfLists": {"target": LIST_OF_LIST_OF_STRINGS}, - "ListOfMapsOfStrings": {"target": LIST_OF_MAPS_OF_STRINGS}, - "ListOfStrings": {"target": LIST_OF_STRINGS}, - "ListOfStructs": {"target": LIST_OF_STRUCTS}, - "Long": {"target": LONG}, - "MapOfListsOfStrings": {"target": MAP_OF_LISTS_OF_STRINGS}, - "MapOfMaps": {"target": MAP_OF_MAP_OF_STRINGS}, - "MapOfStrings": {"target": MAP_OF_STRINGS}, - "MapOfStructs": {"target": MAP_OF_STRUCTS}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "RecursiveList": None, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "RecursiveMap": None, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "RecursiveStruct": None, - "SimpleStruct": {"target": SIMPLE_STRUCT}, - "String": {"target": STRING}, - "StructWithJsonName": {"target": STRUCT_WITH_JSON_NAME}, - "Timestamp": {"target": TIMESTAMP}, - "UnixTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - }, +JSON_ENUMS_INPUT = ( + 18, + n0, + _JEI, + {_sSI: _aJEIO}, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -LIST_OF_KITCHEN_SINKS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ListOfKitchenSinks"), - shape_type=ShapeType.LIST, - members={"member": {"target": KITCHEN_SINK}}, +JSON_ENUMS_OUTPUT = ( + 18, + n0, + _JEO, + {_sSI: _aJEIO}, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -MAP_OF_KITCHEN_SINKS = Schema.collection( - id=ShapeID("aws.protocoltests.json#MapOfKitchenSinks"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": KITCHEN_SINK}}, -) +JSON_ENUMS = (23, n0, _JE, 0, JSON_ENUMS_INPUT, JSON_ENUMS_OUTPUT, ()) -ERROR_WITH_MEMBERS = Schema.collection( - id=ShapeID("aws.protocoltests.json#ErrorWithMembers"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "Code": {"target": STRING}, - "ComplexData": {"target": KITCHEN_SINK}, - "IntegerField": {"target": INTEGER}, - "ListField": {"target": LIST_OF_STRINGS}, - "MapField": {"target": MAP_OF_STRINGS}, - "Message": {"target": STRING}, - "StringField": {"target": STRING}, - }, -) +INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -KITCHEN_SINK_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#KitchenSinkOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#KitchenSink", - ) - ], - members={ - "Blob": {"target": BLOB}, - "Boolean": {"target": BOOLEAN}, - "Double": {"target": DOUBLE}, - "EmptyStruct": {"target": EMPTY_STRUCT}, - "Float": {"target": FLOAT}, - "HttpdateTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "Integer": {"target": INTEGER}, - "Iso8601Timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "JsonValue": {"target": JSON_VALUE}, - "ListOfLists": {"target": LIST_OF_LIST_OF_STRINGS}, - "ListOfMapsOfStrings": {"target": LIST_OF_MAPS_OF_STRINGS}, - "ListOfStrings": {"target": LIST_OF_STRINGS}, - "ListOfStructs": {"target": LIST_OF_STRUCTS}, - "Long": {"target": LONG}, - "MapOfListsOfStrings": {"target": MAP_OF_LISTS_OF_STRINGS}, - "MapOfMaps": {"target": MAP_OF_MAP_OF_STRINGS}, - "MapOfStrings": {"target": MAP_OF_STRINGS}, - "MapOfStructs": {"target": MAP_OF_STRUCTS}, - "RecursiveList": {"target": LIST_OF_KITCHEN_SINKS}, - "RecursiveMap": {"target": MAP_OF_KITCHEN_SINKS}, - "RecursiveStruct": {"target": KITCHEN_SINK}, - "SimpleStruct": {"target": SIMPLE_STRUCT}, - "String": {"target": STRING}, - "StructWithJsonName": {"target": STRUCT_WITH_JSON_NAME}, - "Timestamp": {"target": TIMESTAMP}, - "UnixTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - }, -) +INTEGER_ENUM_LIST = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -KITCHEN_SINK_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.json#KitchenSinkOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.json#KitchenSink", - ) - ], - members={ - "Blob": {"target": BLOB}, - "Boolean": {"target": BOOLEAN}, - "Double": {"target": DOUBLE}, - "EmptyStruct": {"target": EMPTY_STRUCT}, - "Float": {"target": FLOAT}, - "HttpdateTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "Integer": {"target": INTEGER}, - "Iso8601Timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "JsonValue": {"target": JSON_VALUE}, - "ListOfLists": {"target": LIST_OF_LIST_OF_STRINGS}, - "ListOfMapsOfStrings": {"target": LIST_OF_MAPS_OF_STRINGS}, - "ListOfStrings": {"target": LIST_OF_STRINGS}, - "ListOfStructs": {"target": LIST_OF_STRUCTS}, - "Long": {"target": LONG}, - "MapOfListsOfStrings": {"target": MAP_OF_LISTS_OF_STRINGS}, - "MapOfMaps": {"target": MAP_OF_MAP_OF_STRINGS}, - "MapOfStrings": {"target": MAP_OF_STRINGS}, - "MapOfStructs": {"target": MAP_OF_STRUCTS}, - "RecursiveList": {"target": LIST_OF_KITCHEN_SINKS}, - "RecursiveMap": {"target": MAP_OF_KITCHEN_SINKS}, - "RecursiveStruct": {"target": KITCHEN_SINK}, - "SimpleStruct": {"target": SIMPLE_STRUCT}, - "String": {"target": STRING}, - "StructWithJsonName": {"target": STRUCT_WITH_JSON_NAME}, - "Timestamp": {"target": TIMESTAMP}, - "UnixTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - }, -) +INTEGER_ENUM_MAP = (17, n1, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) -KITCHEN_SINK_OPERATION = Schema( - id=ShapeID("aws.protocoltests.json#KitchenSinkOperation"), - shape_type=ShapeType.OPERATION, +INTEGER_ENUM_SET = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) + +JSON_INT_ENUMS_INPUT = ( + 18, + n0, + _JIEI, + {_sSI: _aJIEIO}, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), +) + +JSON_INT_ENUMS_OUTPUT = ( + 18, + n0, + _JIEO, + {_sSI: _aJIEIO}, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), +) + +JSON_INT_ENUMS = (23, n0, _JIE, 0, JSON_INT_ENUMS_INPUT, JSON_INT_ENUMS_OUTPUT, ()) + +STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) + +STRING_MAP = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) + +GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) + +MY_UNION = ( + 19, + n0, + _MU, + 0, + (_sV, _bV, _nV, _bVl, _tV, _eV, _lV, _mV, _sVt), + ( + (3, 0), + (2, 0), + (7, 0), + (1, 0), + (4, 0), + (FOO_ENUM, 0), + (STRING_LIST, 0), + (STRING_MAP, 0), + (GREETING_STRUCT, 0), + ), +) + +JSON_UNIONS_INPUT = (18, n0, _JUI, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) + +JSON_UNIONS_OUTPUT = (18, n0, _JUO, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) + +JSON_UNIONS = (23, n0, _JU, 0, JSON_UNIONS_INPUT, JSON_UNIONS_OUTPUT, ()) + +NULL_OPERATION_INPUT = (18, n0, _NOI, {_sSI: _aNOIO}, (_st,), ((3, 0),)) + +NULL_OPERATION_OUTPUT = (18, n0, _NOO, {_sSI: _aNOIO}, (_st,), ((3, 0),)) + +NULL_OPERATION = (23, n0, _NO, 0, NULL_OPERATION_INPUT, NULL_OPERATION_OUTPUT, ()) + +OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT = (18, n0, _OWOIOI, 0, (_V,), ((3, 0),)) + +OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT = (18, n0, _OWOIOO, 0, (_V,), ((3, 0),)) + +OPERATION_WITH_OPTIONAL_INPUT_OUTPUT = ( + 23, + n0, + _OWOIO, + 0, + OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT, + OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT, + (), ) -JSON_PROTOCOL = Schema( - id=ShapeID("aws.protocoltests.json#JsonProtocol"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), - value=MappingProxyType({"name": "jsonprotocol"}), - ), - Trait.new(id=ShapeID("aws.protocols#awsJson1_1")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), - } - ), - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), - } - ), - MappingProxyType( +PUT_AND_GET_INLINE_DOCUMENTS_INPUT = ( + 18, + n0, + _PAGIDI, + {_sSI: _aPAGIDIO}, + (_iD,), + ((DOCUMENT, 0),), +) + +PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT = ( + 18, + n0, + _PAGIDO, + {_sSI: _aPAGIDIO}, + (_iD,), + ((DOCUMENT, 0),), +) + +PUT_AND_GET_INLINE_DOCUMENTS = ( + 23, + n0, + _PAGID, + 0, + PUT_AND_GET_INLINE_DOCUMENTS_INPUT, + PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT, + (), +) + +PUT_WITH_CONTENT_ENCODING_INPUT = ( + 18, + n0, + _PWCEI, + 0, + (_e, _da), + ((3, {_sH: _CE_}), (3, 0)), +) + +PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) + +PUT_WITH_CONTENT_ENCODING = ( + 23, + n0, + _PWCE, + {_sC: MappingProxyType({"encodings": ("gzip",)})}, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), +) + +SIMPLE_SCALAR_PROPERTIES_INPUT = ( + 18, + n0, + _SSPI, + {_sSI: _aSSPIO}, + (_fV, _dV), + ((9, 0), (10, 0)), +) + +SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( + 18, + n0, + _SSPO, + {_sSI: _aSSPIO}, + (_fV, _dV), + ((9, 0), (10, 0)), +) + +SIMPLE_SCALAR_PROPERTIES = ( + 23, + n0, + _SSP, + 0, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), +) + +SPARSE_STRING_LIST = (16, n1, _SSL, 64, (_m,), ((3, 0),)) + +SPARSE_STRING_MAP = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (3, 0))) + +SPARSE_NULLS_OPERATION_INPUT = ( + 18, + n0, + _SNOI, + {_sSI: _aSNOIO}, + (_sSL, _sSM), + ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), +) + +SPARSE_NULLS_OPERATION_OUTPUT = ( + 18, + n0, + _SNOO, + {_sSI: _aSNOIO}, + (_sSL, _sSM), + ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), +) + +SPARSE_NULLS_OPERATION = ( + 23, + n0, + _SNO, + 0, + SPARSE_NULLS_OPERATION_INPUT, + SPARSE_NULLS_OPERATION_OUTPUT, + (), +) + +KITCHEN_SINK = ( + 18, + n0, + _KS, + 0, + ( + _Bl, + _Bo, + _Do, + _ES, + _Fl, + _HT, + _I, + _IT, + _JV, + _LOL, + _LOMOS, + _LOS, + _LOSi, + _L, + _MOLOS, + _MOM, + _MOS, + _MOSa, + _RL, + _RMe, + _RS, + _SS, + _S, + _SWJN, + _T, + _UT, + ), + ( + (1, 0), + (2, 0), + (10, 0), + (EMPTY_STRUCT, 0), + (9, 0), + (4, {_sF: _hd}), + (7, 0), + (4, {_sF: _dt}), + (JSON_VALUE, 0), + (LIST_OF_LIST_OF_STRINGS, 0), + (LIST_OF_MAPS_OF_STRINGS, 0), + (LIST_OF_STRINGS, 0), + (LIST_OF_STRUCTS, 0), + (8, 0), + (MAP_OF_LISTS_OF_STRINGS, 0), + (MAP_OF_MAP_OF_STRINGS, 0), + (MAP_OF_STRINGS, 0), + (MAP_OF_STRUCTS, 0), + (lambda: LIST_OF_KITCHEN_SINKS, 0), + (lambda: MAP_OF_KITCHEN_SINKS, 0), + (lambda: KITCHEN_SINK, 0), + (SIMPLE_STRUCT, 0), + (3, 0), + (STRUCT_WITH_JSON_NAME, 0), + (4, 0), + (4, {_sF: _es}), + ), +) + +LIST_OF_KITCHEN_SINKS = (16, n0, _LOKS, 0, (_m,), ((KITCHEN_SINK, 0),)) + +MAP_OF_KITCHEN_SINKS = (17, n0, _MOKS, 0, (_k, _v), ((3, 0), (KITCHEN_SINK, 0))) + +ERROR_WITH_MEMBERS = ( + 18, + n0, + _EWMr, + {_s: _c}, + (_Co, _CD, _IF, _LF, _MF, _M, _SF), + ( + (3, 0), + (KITCHEN_SINK, 0), + (7, 0), + (LIST_OF_STRINGS, 0), + (MAP_OF_STRINGS, 0), + (3, 0), + (3, 0), + ), +) + +KITCHEN_SINK_OPERATION_INPUT = ( + 18, + n0, + _KSOI, + {_sSI: _aKS}, + ( + _Bl, + _Bo, + _Do, + _ES, + _Fl, + _HT, + _I, + _IT, + _JV, + _LOL, + _LOMOS, + _LOS, + _LOSi, + _L, + _MOLOS, + _MOM, + _MOS, + _MOSa, + _RL, + _RMe, + _RS, + _SS, + _S, + _SWJN, + _T, + _UT, + ), + ( + (1, 0), + (2, 0), + (10, 0), + (EMPTY_STRUCT, 0), + (9, 0), + (4, {_sF: _hd}), + (7, 0), + (4, {_sF: _dt}), + (JSON_VALUE, 0), + (LIST_OF_LIST_OF_STRINGS, 0), + (LIST_OF_MAPS_OF_STRINGS, 0), + (LIST_OF_STRINGS, 0), + (LIST_OF_STRUCTS, 0), + (8, 0), + (MAP_OF_LISTS_OF_STRINGS, 0), + (MAP_OF_MAP_OF_STRINGS, 0), + (MAP_OF_STRINGS, 0), + (MAP_OF_STRUCTS, 0), + (LIST_OF_KITCHEN_SINKS, 0), + (MAP_OF_KITCHEN_SINKS, 0), + (KITCHEN_SINK, 0), + (SIMPLE_STRUCT, 0), + (3, 0), + (STRUCT_WITH_JSON_NAME, 0), + (4, 0), + (4, {_sF: _es}), + ), +) + +KITCHEN_SINK_OPERATION_OUTPUT = ( + 18, + n0, + _KSOO, + {_sSI: _aKS}, + ( + _Bl, + _Bo, + _Do, + _ES, + _Fl, + _HT, + _I, + _IT, + _JV, + _LOL, + _LOMOS, + _LOS, + _LOSi, + _L, + _MOLOS, + _MOM, + _MOS, + _MOSa, + _RL, + _RMe, + _RS, + _SS, + _S, + _SWJN, + _T, + _UT, + ), + ( + (1, 0), + (2, 0), + (10, 0), + (EMPTY_STRUCT, 0), + (9, 0), + (4, {_sF: _hd}), + (7, 0), + (4, {_sF: _dt}), + (JSON_VALUE, 0), + (LIST_OF_LIST_OF_STRINGS, 0), + (LIST_OF_MAPS_OF_STRINGS, 0), + (LIST_OF_STRINGS, 0), + (LIST_OF_STRUCTS, 0), + (8, 0), + (MAP_OF_LISTS_OF_STRINGS, 0), + (MAP_OF_MAP_OF_STRINGS, 0), + (MAP_OF_STRINGS, 0), + (MAP_OF_STRUCTS, 0), + (LIST_OF_KITCHEN_SINKS, 0), + (MAP_OF_KITCHEN_SINKS, 0), + (KITCHEN_SINK, 0), + (SIMPLE_STRUCT, 0), + (3, 0), + (STRUCT_WITH_JSON_NAME, 0), + (4, 0), + (4, {_sF: _es}), + ), +) + +KITCHEN_SINK_OPERATION = ( + 23, + n0, + _KSO, + 0, + KITCHEN_SINK_OPERATION_INPUT, + KITCHEN_SINK_OPERATION_OUTPUT, + (ERROR_WITH_MEMBERS, ERROR_WITHOUT_MEMBERS), +) + +JSON_PROTOCOL = ( + 21, + n0, + _JP, + { + _aw: MappingProxyType({"name": "jsonprotocol"}), + _a_: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://jsonprotocol-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://jsonprotocol.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://jsonprotocol-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://jsonprotocol.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://jsonprotocol.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } + ), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonprotocol-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonprotocol.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonprotocol-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonprotocol.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://jsonprotocol.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType( - { - "sdkId": "Json Protocol", - "arnNamespace": "jsonprotocol", - "cloudFormationName": "JsonProtocol", - "cloudTrailEventSource": "jsonprotocol.amazonaws.com", - } - ), + _aws: MappingProxyType( + { + "sdkId": "Json Protocol", + "arnNamespace": "jsonprotocol", + "cloudFormationName": "JsonProtocol", + "cloudTrailEventSource": "jsonprotocol.amazonaws.com", + } ), - ], -) - -KITCHEN_SINK.members["RecursiveList"] = Schema.member( - id=KITCHEN_SINK.id.with_member("RecursiveList"), - target=LIST_OF_KITCHEN_SINKS, - index=18, -) - -KITCHEN_SINK.members["RecursiveMap"] = Schema.member( - id=KITCHEN_SINK.id.with_member("RecursiveMap"), - target=MAP_OF_KITCHEN_SINKS, - index=19, -) - -KITCHEN_SINK.members["RecursiveStruct"] = Schema.member( - id=KITCHEN_SINK.id.with_member("RecursiveStruct"), target=KITCHEN_SINK, index=20 + }, ) diff --git a/codegen-output/aws-json-1-1/src/awsjson11/models.py b/codegen-output/aws-json-1-1/src/awsjson11/models.py index 785831f43..32603ef9c 100644 --- a/codegen-output/aws-json-1-1/src/awsjson11/models.py +++ b/codegen-output/aws-json-1-1/src/awsjson11/models.py @@ -6,6 +6,7 @@ import logging from typing import Any, Literal, Self, Union +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import Document, TypeRegistry from smithy_core.exceptions import ModeledError, SerializationError @@ -104,13 +105,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -119,18 +119,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -145,18 +145,15 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[0], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -165,21 +162,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[0]) case 1: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -190,13 +187,12 @@ class ContentTypeParametersInput: value: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT).members_by_index if self.value is not None: - serializer.write_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"], self.value - ) + serializer.write_integer(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -205,20 +201,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"] - ) + kwargs["value"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -237,7 +231,7 @@ class ContentTypeParametersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -249,27 +243,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONTENT_TYPE_PARAMETERS = APIOperation( input=ContentTypeParametersInput, output=ContentTypeParametersOutput, - schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, - input_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, - output_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, + static_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -278,7 +268,7 @@ class DatetimeOffsetsInput: """Dataclass for DatetimeOffsetsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -290,13 +280,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -317,13 +308,12 @@ class DatetimeOffsetsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -332,30 +322,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DATETIME_OFFSETS = APIOperation( input=DatetimeOffsetsInput, output=DatetimeOffsetsOutput, - schema=_SCHEMA_DATETIME_OFFSETS, - input_schema=_SCHEMA_DATETIME_OFFSETS_INPUT, - output_schema=_SCHEMA_DATETIME_OFFSETS_OUTPUT, + static_schema=_SCHEMA_DATETIME_OFFSETS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -364,7 +351,7 @@ class EmptyOperationInput: """Dataclass for EmptyOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_EMPTY_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -376,13 +363,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_EMPTY_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -401,7 +389,7 @@ class EmptyOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_EMPTY_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -413,25 +401,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_EMPTY_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_OPERATION = APIOperation( input=EmptyOperationInput, output=EmptyOperationOutput, - schema=_SCHEMA_EMPTY_OPERATION, - input_schema=_SCHEMA_EMPTY_OPERATION_INPUT, - output_schema=_SCHEMA_EMPTY_OPERATION_OUTPUT, + static_schema=_SCHEMA_EMPTY_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -440,7 +426,7 @@ class EmptyStruct: """Dataclass for EmptyStruct structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_EMPTY_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -452,13 +438,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_STRUCT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_EMPTY_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -467,7 +454,7 @@ class EndpointOperationInput: """Dataclass for EndpointOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -479,13 +466,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -504,7 +492,7 @@ class EndpointOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -516,25 +504,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_OPERATION = APIOperation( input=EndpointOperationInput, output=EndpointOperationOutput, - schema=_SCHEMA_ENDPOINT_OPERATION, - input_schema=_SCHEMA_ENDPOINT_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -545,14 +531,16 @@ class EndpointWithHostLabelOperationInput: label: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT + ).members_by_index if self.label is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members["label"], - self.label, - ) + serializer.write_string(members[0], self.label) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -561,22 +549,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["label"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members[ - "label" - ] - ) + kwargs["label"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -595,7 +579,9 @@ class EndpointWithHostLabelOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -607,34 +593,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_OPERATION = APIOperation( input=EndpointWithHostLabelOperationInput, output=EndpointWithHostLabelOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_list_of_strings( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -644,7 +626,7 @@ def _deserialize_list_of_strings( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -660,7 +642,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_of_list_of_strings( serializer: ShapeSerializer, schema: Schema, value: list[list[str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_list_of_strings(ls, member_schema, e) @@ -670,7 +652,7 @@ def _deserialize_list_of_list_of_strings( deserializer: ShapeDeserializer, schema: Schema ) -> list[list[str]]: result: list[list[str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -687,7 +669,7 @@ def _serialize_map_of_strings( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -696,7 +678,7 @@ def _deserialize_map_of_strings( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -712,7 +694,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_list_of_maps_of_strings( serializer: ShapeSerializer, schema: Schema, value: list[dict[str, str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_map_of_strings(ls, member_schema, e) @@ -722,7 +704,7 @@ def _deserialize_list_of_maps_of_strings( deserializer: ShapeDeserializer, schema: Schema ) -> list[dict[str, str]]: result: list[dict[str, str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -742,11 +724,12 @@ class SimpleStruct: value: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_STRUCT).members_by_index if self.value is not None: - serializer.write_string(_SCHEMA_SIMPLE_STRUCT.members["Value"], self.value) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -755,25 +738,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_SIMPLE_STRUCT.members["Value"] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SIMPLE_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_list_of_structs( serializer: ShapeSerializer, schema: Schema, value: list[SimpleStruct] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -799,7 +782,7 @@ def _serialize_map_of_lists_of_strings( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_list_of_strings(vs, value_schema, v)) @@ -808,7 +791,7 @@ def _deserialize_map_of_lists_of_strings( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str]]: result: dict[str, list[str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -825,7 +808,7 @@ def _serialize_map_of_map_of_strings( serializer: ShapeSerializer, schema: Schema, value: dict[str, dict[str, str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_map_of_strings(vs, value_schema, v)) @@ -834,7 +817,7 @@ def _deserialize_map_of_map_of_strings( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, dict[str, str]]: result: dict[str, dict[str, str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -851,7 +834,7 @@ def _serialize_map_of_structs( serializer: ShapeSerializer, schema: Schema, value: dict[str, SimpleStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -860,7 +843,7 @@ def _deserialize_map_of_structs( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, SimpleStruct]: result: dict[str, SimpleStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -880,13 +863,12 @@ class StructWithJsonName: value: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCT_WITH_JSON_NAME, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCT_WITH_JSON_NAME), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCT_WITH_JSON_NAME).members_by_index if self.value is not None: - serializer.write_string( - _SCHEMA_STRUCT_WITH_JSON_NAME.members["Value"], self.value - ) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -895,18 +877,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCT_WITH_JSON_NAME) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_STRUCT_WITH_JSON_NAME.members["Value"] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCT_WITH_JSON_NAME, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -917,7 +899,7 @@ class ErrorWithoutMembers(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ERROR_WITHOUT_MEMBERS, self) + serializer.write_struct(hydrate(_SCHEMA_ERROR_WITHOUT_MEMBERS), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -929,13 +911,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ERROR_WITHOUT_MEMBERS) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ERROR_WITHOUT_MEMBERS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -949,7 +932,7 @@ class FooError(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FOO_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_FOO_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -961,13 +944,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FOO_ERROR) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FOO_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -976,7 +960,7 @@ class FractionalSecondsInput: """Dataclass for FractionalSecondsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -988,13 +972,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1015,13 +1000,12 @@ class FractionalSecondsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1030,30 +1014,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FRACTIONAL_SECONDS = APIOperation( input=FractionalSecondsInput, output=FractionalSecondsOutput, - schema=_SCHEMA_FRACTIONAL_SECONDS, - input_schema=_SCHEMA_FRACTIONAL_SECONDS_INPUT, - output_schema=_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, + static_schema=_SCHEMA_FRACTIONAL_SECONDS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1062,7 +1043,7 @@ class GreetingWithErrorsInput: """Dataclass for GreetingWithErrorsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1074,13 +1055,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1101,13 +1083,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1116,20 +1097,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1140,13 +1119,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1155,27 +1133,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.json#InvalidGreeting"): InvalidGreeting, @@ -1184,7 +1160,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_INVALID_GREETING, _SCHEMA_COMPLEX_ERROR, _SCHEMA_FOO_ERROR], ) @@ -1193,7 +1168,7 @@ class HostWithPathOperationInput: """Dataclass for HostWithPathOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1205,15 +1180,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1232,7 +1206,7 @@ class HostWithPathOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1244,27 +1218,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HOST_WITH_PATH_OPERATION = APIOperation( input=HostWithPathOperationInput, output=HostWithPathOperationOutput, - schema=_SCHEMA_HOST_WITH_PATH_OPERATION, - input_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, - output_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, + static_schema=_SCHEMA_HOST_WITH_PATH_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1279,7 +1249,7 @@ class FooEnum(UnknownEnumMixin, StrEnum): def _serialize_foo_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1289,7 +1259,7 @@ def _deserialize_foo_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1306,7 +1276,7 @@ def _serialize_foo_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -1315,7 +1285,7 @@ def _deserialize_foo_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -1331,7 +1301,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_foo_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1341,7 +1311,7 @@ def _deserialize_foo_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1371,44 +1341,27 @@ class JsonEnumsInput: foo_enum_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_ENUMS_INPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1417,43 +1370,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_ENUMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_INPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_INPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_INPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1484,44 +1427,27 @@ class JsonEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_ENUMS_OUTPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1530,55 +1456,42 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_ENUMS = APIOperation( input=JsonEnumsInput, output=JsonEnumsOutput, - schema=_SCHEMA_JSON_ENUMS, - input_schema=_SCHEMA_JSON_ENUMS_INPUT, - output_schema=_SCHEMA_JSON_ENUMS_OUTPUT, + static_schema=_SCHEMA_JSON_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1591,7 +1504,7 @@ class IntegerEnum(UnknownEnumMixin, IntEnum): def _serialize_integer_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -1601,7 +1514,7 @@ def _deserialize_integer_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1618,7 +1531,7 @@ def _serialize_integer_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -1627,7 +1540,7 @@ def _deserialize_integer_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -1643,7 +1556,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_integer_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -1653,7 +1566,7 @@ def _deserialize_integer_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1683,44 +1596,27 @@ class JsonIntEnumsInput: int_enum_map: dict[str, int] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_INT_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_INT_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_INT_ENUMS_INPUT).members_by_index if self.int_enum1 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnum1"], self.int_enum1 - ) + serializer.write_integer(members[0], self.int_enum1) if self.int_enum2 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnum2"], self.int_enum2 - ) + serializer.write_integer(members[1], self.int_enum2) if self.int_enum3 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnum3"], self.int_enum3 - ) + serializer.write_integer(members[2], self.int_enum3) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.int_enum_list) if self.int_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnumSet"], - self.int_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.int_enum_set) if self.int_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnumMap"], - self.int_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.int_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1729,49 +1625,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_INT_ENUMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnum1"] - ) - ) + kwargs["int_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["int_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnum2"] - ) - ) + kwargs["int_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["int_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnum3"] - ) - ) + kwargs["int_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnumList"] + de, members[3] ) case 4: kwargs["int_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnumSet"] + de, members[4] ) case 5: kwargs["int_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_JSON_INT_ENUMS_INPUT.members["intEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_INT_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1802,44 +1688,27 @@ class JsonIntEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_INT_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_INT_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_INT_ENUMS_OUTPUT).members_by_index if self.int_enum1 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnum1"], self.int_enum1 - ) + serializer.write_integer(members[0], self.int_enum1) if self.int_enum2 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnum2"], self.int_enum2 - ) + serializer.write_integer(members[1], self.int_enum2) if self.int_enum3 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnum3"], self.int_enum3 - ) + serializer.write_integer(members[2], self.int_enum3) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.int_enum_list) if self.int_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnumSet"], - self.int_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.int_enum_set) if self.int_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnumMap"], - self.int_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.int_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1848,68 +1717,55 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_INT_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnum1"] - ) - ) + kwargs["int_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["int_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnum2"] - ) - ) + kwargs["int_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["int_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnum3"] - ) - ) + kwargs["int_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnumList"] + de, members[3] ) case 4: kwargs["int_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnumSet"] + de, members[4] ) case 5: kwargs["int_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["intEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_INT_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_INT_ENUMS = APIOperation( input=JsonIntEnumsInput, output=JsonIntEnumsOutput, - schema=_SCHEMA_JSON_INT_ENUMS, - input_schema=_SCHEMA_JSON_INT_ENUMS_INPUT, - output_schema=_SCHEMA_JSON_INT_ENUMS_OUTPUT, + static_schema=_SCHEMA_JSON_INT_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1919,7 +1775,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1936,7 +1792,7 @@ def _serialize_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -1945,7 +1801,7 @@ def _deserialize_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -1965,11 +1821,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1978,16 +1835,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1996,16 +1855,16 @@ class MyUnionStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MY_UNION.members["stringValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_MY_UNION.members["stringValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -2013,16 +1872,16 @@ class MyUnionBooleanValue: value: bool def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_boolean(_SCHEMA_MY_UNION.members["booleanValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_boolean(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_boolean(_SCHEMA_MY_UNION.members["booleanValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_boolean(members[1])) @dataclass @@ -2030,16 +1889,16 @@ class MyUnionNumberValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer(_SCHEMA_MY_UNION.members["numberValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_integer(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_integer(_SCHEMA_MY_UNION.members["numberValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_integer(members[2])) @dataclass @@ -2047,14 +1906,16 @@ class MyUnionBlobValue: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_MY_UNION.members["blobValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_blob(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_blob(_SCHEMA_MY_UNION.members["blobValue"])) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_blob(members[3])) @dataclass @@ -2062,20 +1923,16 @@ class MyUnionTimestampValue: value: datetime def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_timestamp( - _SCHEMA_MY_UNION.members["timestampValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_timestamp(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_timestamp( - _SCHEMA_MY_UNION.members["timestampValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_timestamp(members[4])) @dataclass @@ -2083,18 +1940,16 @@ class MyUnionEnumValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MY_UNION.members["enumValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_string(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=FooEnum( - deserializer.read_string(_SCHEMA_MY_UNION.members["enumValue"]) - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=FooEnum(deserializer.read_string(members[5]))) @dataclass @@ -2102,20 +1957,16 @@ class MyUnionListValue: value: list[str] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_string_list( - serializer, _SCHEMA_MY_UNION.members["listValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + _serialize_string_list(serializer, members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_string_list( - deserializer, _SCHEMA_MY_UNION.members["listValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=_deserialize_string_list(deserializer, members[6])) @dataclass @@ -2123,20 +1974,16 @@ class MyUnionMapValue: value: dict[str, str] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_string_map( - serializer, _SCHEMA_MY_UNION.members["mapValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + _serialize_string_map(serializer, members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_string_map( - deserializer, _SCHEMA_MY_UNION.members["mapValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=_deserialize_string_map(deserializer, members[7])) @dataclass @@ -2144,10 +1991,11 @@ class MyUnionStructureValue: value: GreetingStruct def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION.members["structureValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_struct(members[8], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2198,7 +2046,7 @@ class _MyUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> MyUnion: self._result = None - deserializer.read_struct(_SCHEMA_MY_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_MY_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -2255,13 +2103,12 @@ class JsonUnionsInput: """A union with a representative set of types for members.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_UNIONS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_UNIONS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_UNIONS_INPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_JSON_UNIONS_INPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2270,16 +2117,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_UNIONS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _MyUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_UNIONS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2301,13 +2150,12 @@ class JsonUnionsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_UNIONS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_UNIONS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_UNIONS_OUTPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_JSON_UNIONS_OUTPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2316,28 +2164,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_UNIONS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _MyUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_UNIONS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_UNIONS = APIOperation( input=JsonUnionsInput, output=JsonUnionsOutput, - schema=_SCHEMA_JSON_UNIONS, - input_schema=_SCHEMA_JSON_UNIONS_INPUT, - output_schema=_SCHEMA_JSON_UNIONS_OUTPUT, + static_schema=_SCHEMA_JSON_UNIONS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2348,13 +2195,12 @@ class NullOperationInput: string: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NULL_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_OPERATION_INPUT).members_by_index if self.string is not None: - serializer.write_string( - _SCHEMA_NULL_OPERATION_INPUT.members["string"], self.string - ) + serializer.write_string(members[0], self.string) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2363,18 +2209,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string"] = de.read_string( - _SCHEMA_NULL_OPERATION_INPUT.members["string"] - ) + kwargs["string"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NULL_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2395,13 +2241,12 @@ class NullOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NULL_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_OPERATION_OUTPUT).members_by_index if self.string is not None: - serializer.write_string( - _SCHEMA_NULL_OPERATION_OUTPUT.members["string"], self.string - ) + serializer.write_string(members[0], self.string) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2410,30 +2255,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string"] = de.read_string( - _SCHEMA_NULL_OPERATION_OUTPUT.members["string"] - ) + kwargs["string"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NULL_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NULL_OPERATION = APIOperation( input=NullOperationInput, output=NullOperationOutput, - schema=_SCHEMA_NULL_OPERATION, - input_schema=_SCHEMA_NULL_OPERATION_INPUT, - output_schema=_SCHEMA_NULL_OPERATION_OUTPUT, + static_schema=_SCHEMA_NULL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2445,15 +2287,15 @@ class OperationWithOptionalInputOutputInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT, self + hydrate(_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT + ).members_by_index if self.value is not None: - serializer.write_string( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT.members["Value"], - self.value, - ) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2462,22 +2304,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT.members[ - "Value" - ] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2499,15 +2337,15 @@ class OperationWithOptionalInputOutputOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT, self + hydrate(_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT + ).members_by_index if self.value is not None: - serializer.write_string( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT.members["Value"], - self.value, - ) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2516,34 +2354,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT.members[ - "Value" - ] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OPERATION_WITH_OPTIONAL_INPUT_OUTPUT = APIOperation( input=OperationWithOptionalInputOutputInput, output=OperationWithOptionalInputOutputOutput, - schema=_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT, - input_schema=_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_OPTIONAL_INPUT_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2554,14 +2385,14 @@ class PutAndGetInlineDocumentsInput: inline_document: Document | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT).members_by_index if self.inline_document is not None: - serializer.write_document( - _SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT.members["inlineDocument"], - self.inline_document, - ) + serializer.write_document(members[0], self.inline_document) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2570,22 +2401,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["inline_document"] = de.read_document( - _SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT.members[ - "inlineDocument" - ] - ) + kwargs["inline_document"] = de.read_document(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2606,14 +2433,14 @@ class PutAndGetInlineDocumentsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT).members_by_index if self.inline_document is not None: - serializer.write_document( - _SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT.members["inlineDocument"], - self.inline_document, - ) + serializer.write_document(members[0], self.inline_document) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2622,34 +2449,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["inline_document"] = de.read_document( - _SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT.members[ - "inlineDocument" - ] - ) + kwargs["inline_document"] = de.read_document(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_AND_GET_INLINE_DOCUMENTS = APIOperation( input=PutAndGetInlineDocumentsInput, output=PutAndGetInlineDocumentsOutput, - schema=_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS, - input_schema=_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_INPUT, - output_schema=_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT, + static_schema=_SCHEMA_PUT_AND_GET_INLINE_DOCUMENTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2662,19 +2482,15 @@ class PutWithContentEncodingInput: data: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT).members_by_index if self.encoding is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"], - self.encoding, - ) + serializer.write_string(members[0], self.encoding) if self.data is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"], self.data - ) + serializer.write_string(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2683,25 +2499,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["encoding"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"] - ) + kwargs["encoding"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"] - ) + kwargs["data"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2720,7 +2532,7 @@ class PutWithContentEncodingOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2732,27 +2544,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_WITH_CONTENT_ENCODING = APIOperation( input=PutWithContentEncodingInput, output=PutWithContentEncodingOutput, - schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, - input_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, - output_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, + static_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2765,20 +2573,15 @@ class SimpleScalarPropertiesInput: double_value: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT).members_by_index if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[0], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[1], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2787,25 +2590,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[0]) case 1: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2828,20 +2627,15 @@ class SimpleScalarPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT).members_by_index if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[0], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[1], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2850,44 +2644,37 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[0]) case 1: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_PROPERTIES = APIOperation( input=SimpleScalarPropertiesInput, output=SimpleScalarPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_sparse_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str | None] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: if e is None: @@ -2900,7 +2687,7 @@ def _deserialize_sparse_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str | None]: result: list[str | None] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2917,7 +2704,7 @@ def _serialize_sparse_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -2929,7 +2716,7 @@ def _deserialize_sparse_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str | None]: result: dict[str, str | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2951,22 +2738,17 @@ class SparseNullsOperationInput: sparse_string_map: dict[str, str | None] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT).members_by_index if self.sparse_string_list is not None: _serialize_sparse_string_list( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members["sparseStringList"], - self.sparse_string_list, + serializer, members[0], self.sparse_string_list ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[1], self.sparse_string_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2975,29 +2757,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_string_list"] = _deserialize_sparse_string_list( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members[ - "sparseStringList" - ], + de, members[0] ) case 1: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members["sparseStringMap"], + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3020,22 +2798,17 @@ class SparseNullsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT).members_by_index if self.sparse_string_list is not None: _serialize_sparse_string_list( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members["sparseStringList"], - self.sparse_string_list, + serializer, members[0], self.sparse_string_list ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[1], self.sparse_string_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3044,43 +2817,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_string_list"] = _deserialize_sparse_string_list( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members[ - "sparseStringList" - ], + de, members[0] ) case 1: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members[ - "sparseStringMap" - ], + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SPARSE_NULLS_OPERATION = APIOperation( input=SparseNullsOperationInput, output=SparseNullsOperationOutput, - schema=_SCHEMA_SPARSE_NULLS_OPERATION, - input_schema=_SCHEMA_SPARSE_NULLS_OPERATION_INPUT, - output_schema=_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT, + static_schema=_SCHEMA_SPARSE_NULLS_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3141,148 +2905,95 @@ class KitchenSink: unix_timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_KITCHEN_SINK, self) + serializer.write_struct(hydrate(_SCHEMA_KITCHEN_SINK), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_KITCHEN_SINK).members_by_index if self.blob is not None: - serializer.write_blob(_SCHEMA_KITCHEN_SINK.members["Blob"], self.blob) + serializer.write_blob(members[0], self.blob) if self.boolean is not None: - serializer.write_boolean( - _SCHEMA_KITCHEN_SINK.members["Boolean"], self.boolean - ) + serializer.write_boolean(members[1], self.boolean) if self.double is not None: - serializer.write_double(_SCHEMA_KITCHEN_SINK.members["Double"], self.double) + serializer.write_double(members[2], self.double) if self.empty_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK.members["EmptyStruct"], self.empty_struct - ) + serializer.write_struct(members[3], self.empty_struct) if self.float_ is not None: - serializer.write_float(_SCHEMA_KITCHEN_SINK.members["Float"], self.float_) + serializer.write_float(members[4], self.float_) if self.httpdate_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK.members["HttpdateTimestamp"], - self.httpdate_timestamp, - ) + serializer.write_timestamp(members[5], self.httpdate_timestamp) if self.integer is not None: - serializer.write_integer( - _SCHEMA_KITCHEN_SINK.members["Integer"], self.integer - ) + serializer.write_integer(members[6], self.integer) if self.iso8601_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK.members["Iso8601Timestamp"], self.iso8601_timestamp - ) + serializer.write_timestamp(members[7], self.iso8601_timestamp) if self.json_value is not None: - serializer.write_string( - _SCHEMA_KITCHEN_SINK.members["JsonValue"], self.json_value - ) + serializer.write_string(members[8], self.json_value) if self.list_of_lists is not None: _serialize_list_of_list_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK.members["ListOfLists"], - self.list_of_lists, + serializer, members[9], self.list_of_lists ) if self.list_of_maps_of_strings is not None: _serialize_list_of_maps_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK.members["ListOfMapsOfStrings"], - self.list_of_maps_of_strings, + serializer, members[10], self.list_of_maps_of_strings ) if self.list_of_strings is not None: - _serialize_list_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK.members["ListOfStrings"], - self.list_of_strings, - ) + _serialize_list_of_strings(serializer, members[11], self.list_of_strings) if self.list_of_structs is not None: - _serialize_list_of_structs( - serializer, - _SCHEMA_KITCHEN_SINK.members["ListOfStructs"], - self.list_of_structs, - ) + _serialize_list_of_structs(serializer, members[12], self.list_of_structs) if self.long is not None: - serializer.write_long(_SCHEMA_KITCHEN_SINK.members["Long"], self.long) + serializer.write_long(members[13], self.long) if self.map_of_lists_of_strings is not None: _serialize_map_of_lists_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK.members["MapOfListsOfStrings"], - self.map_of_lists_of_strings, + serializer, members[14], self.map_of_lists_of_strings ) if self.map_of_maps is not None: - _serialize_map_of_map_of_strings( - serializer, _SCHEMA_KITCHEN_SINK.members["MapOfMaps"], self.map_of_maps - ) + _serialize_map_of_map_of_strings(serializer, members[15], self.map_of_maps) if self.map_of_strings is not None: - _serialize_map_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK.members["MapOfStrings"], - self.map_of_strings, - ) + _serialize_map_of_strings(serializer, members[16], self.map_of_strings) if self.map_of_structs is not None: - _serialize_map_of_structs( - serializer, - _SCHEMA_KITCHEN_SINK.members["MapOfStructs"], - self.map_of_structs, - ) + _serialize_map_of_structs(serializer, members[17], self.map_of_structs) if self.recursive_list is not None: _serialize_list_of_kitchen_sinks( - serializer, - _SCHEMA_KITCHEN_SINK.members["RecursiveList"], - self.recursive_list, + serializer, members[18], self.recursive_list ) if self.recursive_map is not None: - _serialize_map_of_kitchen_sinks( - serializer, - _SCHEMA_KITCHEN_SINK.members["RecursiveMap"], - self.recursive_map, - ) + _serialize_map_of_kitchen_sinks(serializer, members[19], self.recursive_map) if self.recursive_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK.members["RecursiveStruct"], self.recursive_struct - ) + serializer.write_struct(members[20], self.recursive_struct) if self.simple_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK.members["SimpleStruct"], self.simple_struct - ) + serializer.write_struct(members[21], self.simple_struct) if self.string is not None: - serializer.write_string(_SCHEMA_KITCHEN_SINK.members["String"], self.string) + serializer.write_string(members[22], self.string) if self.struct_with_json_name is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK.members["StructWithJsonName"], - self.struct_with_json_name, - ) + serializer.write_struct(members[23], self.struct_with_json_name) if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK.members["Timestamp"], self.timestamp - ) + serializer.write_timestamp(members[24], self.timestamp) if self.unix_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK.members["UnixTimestamp"], self.unix_timestamp - ) + serializer.write_timestamp(members[25], self.unix_timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3291,105 +3002,89 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_KITCHEN_SINK) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["blob"] = de.read_blob(_SCHEMA_KITCHEN_SINK.members["Blob"]) + kwargs["blob"] = de.read_blob(members[0]) case 1: - kwargs["boolean"] = de.read_boolean( - _SCHEMA_KITCHEN_SINK.members["Boolean"] - ) + kwargs["boolean"] = de.read_boolean(members[1]) case 2: - kwargs["double"] = de.read_double( - _SCHEMA_KITCHEN_SINK.members["Double"] - ) + kwargs["double"] = de.read_double(members[2]) case 3: kwargs["empty_struct"] = EmptyStruct.deserialize(de) case 4: - kwargs["float_"] = de.read_float( - _SCHEMA_KITCHEN_SINK.members["Float"] - ) + kwargs["float_"] = de.read_float(members[4]) case 5: - kwargs["httpdate_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK.members["HttpdateTimestamp"] - ) + kwargs["httpdate_timestamp"] = de.read_timestamp(members[5]) case 6: - kwargs["integer"] = de.read_integer( - _SCHEMA_KITCHEN_SINK.members["Integer"] - ) + kwargs["integer"] = de.read_integer(members[6]) case 7: - kwargs["iso8601_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK.members["Iso8601Timestamp"] - ) + kwargs["iso8601_timestamp"] = de.read_timestamp(members[7]) case 8: - kwargs["json_value"] = de.read_string( - _SCHEMA_KITCHEN_SINK.members["JsonValue"] - ) + kwargs["json_value"] = de.read_string(members[8]) case 9: kwargs["list_of_lists"] = _deserialize_list_of_list_of_strings( - de, _SCHEMA_KITCHEN_SINK.members["ListOfLists"] + de, members[9] ) case 10: kwargs["list_of_maps_of_strings"] = ( - _deserialize_list_of_maps_of_strings( - de, _SCHEMA_KITCHEN_SINK.members["ListOfMapsOfStrings"] - ) + _deserialize_list_of_maps_of_strings(de, members[10]) ) case 11: kwargs["list_of_strings"] = _deserialize_list_of_strings( - de, _SCHEMA_KITCHEN_SINK.members["ListOfStrings"] + de, members[11] ) case 12: kwargs["list_of_structs"] = _deserialize_list_of_structs( - de, _SCHEMA_KITCHEN_SINK.members["ListOfStructs"] + de, members[12] ) case 13: - kwargs["long"] = de.read_long(_SCHEMA_KITCHEN_SINK.members["Long"]) + kwargs["long"] = de.read_long(members[13]) case 14: kwargs["map_of_lists_of_strings"] = ( - _deserialize_map_of_lists_of_strings( - de, _SCHEMA_KITCHEN_SINK.members["MapOfListsOfStrings"] - ) + _deserialize_map_of_lists_of_strings(de, members[14]) ) case 15: kwargs["map_of_maps"] = _deserialize_map_of_map_of_strings( - de, _SCHEMA_KITCHEN_SINK.members["MapOfMaps"] + de, members[15] ) case 16: kwargs["map_of_strings"] = _deserialize_map_of_strings( - de, _SCHEMA_KITCHEN_SINK.members["MapOfStrings"] + de, members[16] ) case 17: kwargs["map_of_structs"] = _deserialize_map_of_structs( - de, _SCHEMA_KITCHEN_SINK.members["MapOfStructs"] + de, members[17] ) case 18: kwargs["recursive_list"] = _deserialize_list_of_kitchen_sinks( - de, _SCHEMA_KITCHEN_SINK.members["RecursiveList"] + de, members[18] ) case 19: kwargs["recursive_map"] = _deserialize_map_of_kitchen_sinks( - de, _SCHEMA_KITCHEN_SINK.members["RecursiveMap"] + de, members[19] ) case 20: @@ -3399,34 +3094,28 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["simple_struct"] = SimpleStruct.deserialize(de) case 22: - kwargs["string"] = de.read_string( - _SCHEMA_KITCHEN_SINK.members["String"] - ) + kwargs["string"] = de.read_string(members[22]) case 23: kwargs["struct_with_json_name"] = StructWithJsonName.deserialize(de) case 24: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK.members["Timestamp"] - ) + kwargs["timestamp"] = de.read_timestamp(members[24]) case 25: - kwargs["unix_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK.members["UnixTimestamp"] - ) + kwargs["unix_timestamp"] = de.read_timestamp(members[25]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_KITCHEN_SINK, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_list_of_kitchen_sinks( serializer: ShapeSerializer, schema: Schema, value: list[KitchenSink] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3452,7 +3141,7 @@ def _serialize_map_of_kitchen_sinks( serializer: ShapeSerializer, schema: Schema, value: dict[str, KitchenSink] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -3461,7 +3150,7 @@ def _deserialize_map_of_kitchen_sinks( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, KitchenSink]: result: dict[str, KitchenSink] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -3494,47 +3183,30 @@ class ErrorWithMembers(ServiceError): """abc""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ERROR_WITH_MEMBERS, self) + serializer.write_struct(hydrate(_SCHEMA_ERROR_WITH_MEMBERS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_ERROR_WITH_MEMBERS).members_by_index if self.code is not None: - serializer.write_string( - _SCHEMA_ERROR_WITH_MEMBERS.members["Code"], self.code - ) + serializer.write_string(members[0], self.code) if self.complex_data is not None: - serializer.write_struct( - _SCHEMA_ERROR_WITH_MEMBERS.members["ComplexData"], self.complex_data - ) + serializer.write_struct(members[1], self.complex_data) if self.integer_field is not None: - serializer.write_integer( - _SCHEMA_ERROR_WITH_MEMBERS.members["IntegerField"], self.integer_field - ) + serializer.write_integer(members[2], self.integer_field) if self.list_field is not None: - _serialize_list_of_strings( - serializer, - _SCHEMA_ERROR_WITH_MEMBERS.members["ListField"], - self.list_field, - ) + _serialize_list_of_strings(serializer, members[3], self.list_field) if self.map_field is not None: - _serialize_map_of_strings( - serializer, - _SCHEMA_ERROR_WITH_MEMBERS.members["MapField"], - self.map_field, - ) + _serialize_map_of_strings(serializer, members[4], self.map_field) if self.message is not None: - serializer.write_string( - _SCHEMA_ERROR_WITH_MEMBERS.members["Message"], self.message - ) + serializer.write_string(members[5], self.message) if self.string_field is not None: - serializer.write_string( - _SCHEMA_ERROR_WITH_MEMBERS.members["StringField"], self.string_field - ) + serializer.write_string(members[6], self.string_field) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3543,46 +3215,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ERROR_WITH_MEMBERS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["code"] = de.read_string( - _SCHEMA_ERROR_WITH_MEMBERS.members["Code"] - ) + kwargs["code"] = de.read_string(members[0]) case 1: kwargs["complex_data"] = KitchenSink.deserialize(de) case 2: - kwargs["integer_field"] = de.read_integer( - _SCHEMA_ERROR_WITH_MEMBERS.members["IntegerField"] - ) + kwargs["integer_field"] = de.read_integer(members[2]) case 3: - kwargs["list_field"] = _deserialize_list_of_strings( - de, _SCHEMA_ERROR_WITH_MEMBERS.members["ListField"] - ) + kwargs["list_field"] = _deserialize_list_of_strings(de, members[3]) case 4: - kwargs["map_field"] = _deserialize_map_of_strings( - de, _SCHEMA_ERROR_WITH_MEMBERS.members["MapField"] - ) + kwargs["map_field"] = _deserialize_map_of_strings(de, members[4]) case 5: - kwargs["message"] = de.read_string( - _SCHEMA_ERROR_WITH_MEMBERS.members["Message"] - ) + kwargs["message"] = de.read_string(members[5]) case 6: - kwargs["string_field"] = de.read_string( - _SCHEMA_ERROR_WITH_MEMBERS.members["StringField"] - ) + kwargs["string_field"] = de.read_string(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ERROR_WITH_MEMBERS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3643,167 +3305,95 @@ class KitchenSinkOperationInput: unix_timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_KITCHEN_SINK_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_KITCHEN_SINK_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_KITCHEN_SINK_OPERATION_INPUT).members_by_index if self.blob is not None: - serializer.write_blob( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Blob"], self.blob - ) + serializer.write_blob(members[0], self.blob) if self.boolean is not None: - serializer.write_boolean( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Boolean"], self.boolean - ) + serializer.write_boolean(members[1], self.boolean) if self.double is not None: - serializer.write_double( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Double"], self.double - ) + serializer.write_double(members[2], self.double) if self.empty_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["EmptyStruct"], - self.empty_struct, - ) + serializer.write_struct(members[3], self.empty_struct) if self.float_ is not None: - serializer.write_float( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Float"], self.float_ - ) + serializer.write_float(members[4], self.float_) if self.httpdate_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["HttpdateTimestamp"], - self.httpdate_timestamp, - ) + serializer.write_timestamp(members[5], self.httpdate_timestamp) if self.integer is not None: - serializer.write_integer( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Integer"], self.integer - ) + serializer.write_integer(members[6], self.integer) if self.iso8601_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Iso8601Timestamp"], - self.iso8601_timestamp, - ) + serializer.write_timestamp(members[7], self.iso8601_timestamp) if self.json_value is not None: - serializer.write_string( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["JsonValue"], - self.json_value, - ) + serializer.write_string(members[8], self.json_value) if self.list_of_lists is not None: _serialize_list_of_list_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfLists"], - self.list_of_lists, + serializer, members[9], self.list_of_lists ) if self.list_of_maps_of_strings is not None: _serialize_list_of_maps_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfMapsOfStrings"], - self.list_of_maps_of_strings, + serializer, members[10], self.list_of_maps_of_strings ) if self.list_of_strings is not None: - _serialize_list_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfStrings"], - self.list_of_strings, - ) + _serialize_list_of_strings(serializer, members[11], self.list_of_strings) if self.list_of_structs is not None: - _serialize_list_of_structs( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfStructs"], - self.list_of_structs, - ) + _serialize_list_of_structs(serializer, members[12], self.list_of_structs) if self.long is not None: - serializer.write_long( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Long"], self.long - ) + serializer.write_long(members[13], self.long) if self.map_of_lists_of_strings is not None: _serialize_map_of_lists_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfListsOfStrings"], - self.map_of_lists_of_strings, + serializer, members[14], self.map_of_lists_of_strings ) if self.map_of_maps is not None: - _serialize_map_of_map_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfMaps"], - self.map_of_maps, - ) + _serialize_map_of_map_of_strings(serializer, members[15], self.map_of_maps) if self.map_of_strings is not None: - _serialize_map_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfStrings"], - self.map_of_strings, - ) + _serialize_map_of_strings(serializer, members[16], self.map_of_strings) if self.map_of_structs is not None: - _serialize_map_of_structs( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfStructs"], - self.map_of_structs, - ) + _serialize_map_of_structs(serializer, members[17], self.map_of_structs) if self.recursive_list is not None: _serialize_list_of_kitchen_sinks( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["RecursiveList"], - self.recursive_list, + serializer, members[18], self.recursive_list ) if self.recursive_map is not None: - _serialize_map_of_kitchen_sinks( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["RecursiveMap"], - self.recursive_map, - ) + _serialize_map_of_kitchen_sinks(serializer, members[19], self.recursive_map) if self.recursive_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["RecursiveStruct"], - self.recursive_struct, - ) + serializer.write_struct(members[20], self.recursive_struct) if self.simple_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["SimpleStruct"], - self.simple_struct, - ) + serializer.write_struct(members[21], self.simple_struct) if self.string is not None: - serializer.write_string( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["String"], self.string - ) + serializer.write_string(members[22], self.string) if self.struct_with_json_name is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["StructWithJsonName"], - self.struct_with_json_name, - ) + serializer.write_struct(members[23], self.struct_with_json_name) if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[24], self.timestamp) if self.unix_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["UnixTimestamp"], - self.unix_timestamp, - ) + serializer.write_timestamp(members[25], self.unix_timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3812,120 +3402,89 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_KITCHEN_SINK_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["blob"] = de.read_blob( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Blob"] - ) + kwargs["blob"] = de.read_blob(members[0]) case 1: - kwargs["boolean"] = de.read_boolean( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Boolean"] - ) + kwargs["boolean"] = de.read_boolean(members[1]) case 2: - kwargs["double"] = de.read_double( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Double"] - ) + kwargs["double"] = de.read_double(members[2]) case 3: kwargs["empty_struct"] = EmptyStruct.deserialize(de) case 4: - kwargs["float_"] = de.read_float( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Float"] - ) + kwargs["float_"] = de.read_float(members[4]) case 5: - kwargs["httpdate_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members[ - "HttpdateTimestamp" - ] - ) + kwargs["httpdate_timestamp"] = de.read_timestamp(members[5]) case 6: - kwargs["integer"] = de.read_integer( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Integer"] - ) + kwargs["integer"] = de.read_integer(members[6]) case 7: - kwargs["iso8601_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Iso8601Timestamp"] - ) + kwargs["iso8601_timestamp"] = de.read_timestamp(members[7]) case 8: - kwargs["json_value"] = de.read_string( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["JsonValue"] - ) + kwargs["json_value"] = de.read_string(members[8]) case 9: kwargs["list_of_lists"] = _deserialize_list_of_list_of_strings( - de, _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfLists"] + de, members[9] ) case 10: kwargs["list_of_maps_of_strings"] = ( - _deserialize_list_of_maps_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members[ - "ListOfMapsOfStrings" - ], - ) + _deserialize_list_of_maps_of_strings(de, members[10]) ) case 11: kwargs["list_of_strings"] = _deserialize_list_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfStrings"], + de, members[11] ) case 12: kwargs["list_of_structs"] = _deserialize_list_of_structs( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["ListOfStructs"], + de, members[12] ) case 13: - kwargs["long"] = de.read_long( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Long"] - ) + kwargs["long"] = de.read_long(members[13]) case 14: kwargs["map_of_lists_of_strings"] = ( - _deserialize_map_of_lists_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members[ - "MapOfListsOfStrings" - ], - ) + _deserialize_map_of_lists_of_strings(de, members[14]) ) case 15: kwargs["map_of_maps"] = _deserialize_map_of_map_of_strings( - de, _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfMaps"] + de, members[15] ) case 16: kwargs["map_of_strings"] = _deserialize_map_of_strings( - de, _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfStrings"] + de, members[16] ) case 17: kwargs["map_of_structs"] = _deserialize_map_of_structs( - de, _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["MapOfStructs"] + de, members[17] ) case 18: kwargs["recursive_list"] = _deserialize_list_of_kitchen_sinks( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["RecursiveList"], + de, members[18] ) case 19: kwargs["recursive_map"] = _deserialize_map_of_kitchen_sinks( - de, _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["RecursiveMap"] + de, members[19] ) case 20: @@ -3935,29 +3494,21 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["simple_struct"] = SimpleStruct.deserialize(de) case 22: - kwargs["string"] = de.read_string( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["String"] - ) + kwargs["string"] = de.read_string(members[22]) case 23: kwargs["struct_with_json_name"] = StructWithJsonName.deserialize(de) case 24: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["Timestamp"] - ) + kwargs["timestamp"] = de.read_timestamp(members[24]) case 25: - kwargs["unix_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT.members["UnixTimestamp"] - ) + kwargs["unix_timestamp"] = de.read_timestamp(members[25]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4028,167 +3579,95 @@ class KitchenSinkOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT).members_by_index if self.blob is not None: - serializer.write_blob( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Blob"], self.blob - ) + serializer.write_blob(members[0], self.blob) if self.boolean is not None: - serializer.write_boolean( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Boolean"], self.boolean - ) + serializer.write_boolean(members[1], self.boolean) if self.double is not None: - serializer.write_double( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Double"], self.double - ) + serializer.write_double(members[2], self.double) if self.empty_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["EmptyStruct"], - self.empty_struct, - ) + serializer.write_struct(members[3], self.empty_struct) if self.float_ is not None: - serializer.write_float( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Float"], self.float_ - ) + serializer.write_float(members[4], self.float_) if self.httpdate_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["HttpdateTimestamp"], - self.httpdate_timestamp, - ) + serializer.write_timestamp(members[5], self.httpdate_timestamp) if self.integer is not None: - serializer.write_integer( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Integer"], self.integer - ) + serializer.write_integer(members[6], self.integer) if self.iso8601_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Iso8601Timestamp"], - self.iso8601_timestamp, - ) + serializer.write_timestamp(members[7], self.iso8601_timestamp) if self.json_value is not None: - serializer.write_string( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["JsonValue"], - self.json_value, - ) + serializer.write_string(members[8], self.json_value) if self.list_of_lists is not None: _serialize_list_of_list_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfLists"], - self.list_of_lists, + serializer, members[9], self.list_of_lists ) if self.list_of_maps_of_strings is not None: _serialize_list_of_maps_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfMapsOfStrings"], - self.list_of_maps_of_strings, + serializer, members[10], self.list_of_maps_of_strings ) if self.list_of_strings is not None: - _serialize_list_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfStrings"], - self.list_of_strings, - ) + _serialize_list_of_strings(serializer, members[11], self.list_of_strings) if self.list_of_structs is not None: - _serialize_list_of_structs( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfStructs"], - self.list_of_structs, - ) + _serialize_list_of_structs(serializer, members[12], self.list_of_structs) if self.long is not None: - serializer.write_long( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Long"], self.long - ) + serializer.write_long(members[13], self.long) if self.map_of_lists_of_strings is not None: _serialize_map_of_lists_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfListsOfStrings"], - self.map_of_lists_of_strings, + serializer, members[14], self.map_of_lists_of_strings ) if self.map_of_maps is not None: - _serialize_map_of_map_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfMaps"], - self.map_of_maps, - ) + _serialize_map_of_map_of_strings(serializer, members[15], self.map_of_maps) if self.map_of_strings is not None: - _serialize_map_of_strings( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfStrings"], - self.map_of_strings, - ) + _serialize_map_of_strings(serializer, members[16], self.map_of_strings) if self.map_of_structs is not None: - _serialize_map_of_structs( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfStructs"], - self.map_of_structs, - ) + _serialize_map_of_structs(serializer, members[17], self.map_of_structs) if self.recursive_list is not None: _serialize_list_of_kitchen_sinks( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["RecursiveList"], - self.recursive_list, + serializer, members[18], self.recursive_list ) if self.recursive_map is not None: - _serialize_map_of_kitchen_sinks( - serializer, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["RecursiveMap"], - self.recursive_map, - ) + _serialize_map_of_kitchen_sinks(serializer, members[19], self.recursive_map) if self.recursive_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["RecursiveStruct"], - self.recursive_struct, - ) + serializer.write_struct(members[20], self.recursive_struct) if self.simple_struct is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["SimpleStruct"], - self.simple_struct, - ) + serializer.write_struct(members[21], self.simple_struct) if self.string is not None: - serializer.write_string( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["String"], self.string - ) + serializer.write_string(members[22], self.string) if self.struct_with_json_name is not None: - serializer.write_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["StructWithJsonName"], - self.struct_with_json_name, - ) + serializer.write_struct(members[23], self.struct_with_json_name) if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[24], self.timestamp) if self.unix_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["UnixTimestamp"], - self.unix_timestamp, - ) + serializer.write_timestamp(members[25], self.unix_timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4197,125 +3676,89 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["blob"] = de.read_blob( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Blob"] - ) + kwargs["blob"] = de.read_blob(members[0]) case 1: - kwargs["boolean"] = de.read_boolean( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Boolean"] - ) + kwargs["boolean"] = de.read_boolean(members[1]) case 2: - kwargs["double"] = de.read_double( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Double"] - ) + kwargs["double"] = de.read_double(members[2]) case 3: kwargs["empty_struct"] = EmptyStruct.deserialize(de) case 4: - kwargs["float_"] = de.read_float( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Float"] - ) + kwargs["float_"] = de.read_float(members[4]) case 5: - kwargs["httpdate_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members[ - "HttpdateTimestamp" - ] - ) + kwargs["httpdate_timestamp"] = de.read_timestamp(members[5]) case 6: - kwargs["integer"] = de.read_integer( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Integer"] - ) + kwargs["integer"] = de.read_integer(members[6]) case 7: - kwargs["iso8601_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members[ - "Iso8601Timestamp" - ] - ) + kwargs["iso8601_timestamp"] = de.read_timestamp(members[7]) case 8: - kwargs["json_value"] = de.read_string( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["JsonValue"] - ) + kwargs["json_value"] = de.read_string(members[8]) case 9: kwargs["list_of_lists"] = _deserialize_list_of_list_of_strings( - de, _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfLists"] + de, members[9] ) case 10: kwargs["list_of_maps_of_strings"] = ( - _deserialize_list_of_maps_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members[ - "ListOfMapsOfStrings" - ], - ) + _deserialize_list_of_maps_of_strings(de, members[10]) ) case 11: kwargs["list_of_strings"] = _deserialize_list_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfStrings"], + de, members[11] ) case 12: kwargs["list_of_structs"] = _deserialize_list_of_structs( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["ListOfStructs"], + de, members[12] ) case 13: - kwargs["long"] = de.read_long( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Long"] - ) + kwargs["long"] = de.read_long(members[13]) case 14: kwargs["map_of_lists_of_strings"] = ( - _deserialize_map_of_lists_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members[ - "MapOfListsOfStrings" - ], - ) + _deserialize_map_of_lists_of_strings(de, members[14]) ) case 15: kwargs["map_of_maps"] = _deserialize_map_of_map_of_strings( - de, _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfMaps"] + de, members[15] ) case 16: kwargs["map_of_strings"] = _deserialize_map_of_strings( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfStrings"], + de, members[16] ) case 17: kwargs["map_of_structs"] = _deserialize_map_of_structs( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["MapOfStructs"], + de, members[17] ) case 18: kwargs["recursive_list"] = _deserialize_list_of_kitchen_sinks( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["RecursiveList"], + de, members[18] ) case 19: kwargs["recursive_map"] = _deserialize_map_of_kitchen_sinks( - de, - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["RecursiveMap"], + de, members[19] ) case 20: @@ -4325,38 +3768,28 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: kwargs["simple_struct"] = SimpleStruct.deserialize(de) case 22: - kwargs["string"] = de.read_string( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["String"] - ) + kwargs["string"] = de.read_string(members[22]) case 23: kwargs["struct_with_json_name"] = StructWithJsonName.deserialize(de) case 24: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["Timestamp"] - ) + kwargs["timestamp"] = de.read_timestamp(members[24]) case 25: - kwargs["unix_timestamp"] = de.read_timestamp( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT.members["UnixTimestamp"] - ) + kwargs["unix_timestamp"] = de.read_timestamp(members[25]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs KITCHEN_SINK_OPERATION = APIOperation( input=KitchenSinkOperationInput, output=KitchenSinkOperationOutput, - schema=_SCHEMA_KITCHEN_SINK_OPERATION, - input_schema=_SCHEMA_KITCHEN_SINK_OPERATION_INPUT, - output_schema=_SCHEMA_KITCHEN_SINK_OPERATION_OUTPUT, + static_schema=_SCHEMA_KITCHEN_SINK_OPERATION, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.json#ErrorWithMembers"): ErrorWithMembers, @@ -4364,5 +3797,4 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_ERROR_WITH_MEMBERS, _SCHEMA_ERROR_WITHOUT_MEMBERS], ) diff --git a/codegen-output/aws-query/pyproject.toml b/codegen-output/aws-query/pyproject.toml index 7fda39478..20a41fc0b 100644 --- a/codegen-output/aws-query/pyproject.toml +++ b/codegen-output/aws-query/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/aws-query/src/awsquery/_private/schemas.py b/codegen-output/aws-query/src/awsquery/_private/schemas.py index e90e8d97b..8a2deb936 100644 --- a/codegen-output/aws-query/src/awsquery/_private/schemas.py +++ b/codegen-output/aws-query/src/awsquery/_private/schemas.py @@ -2,1642 +2,1322 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - BYTE, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -DATETIME_OFFSETS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#DatetimeOffsetsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.shared#DateTime"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], -) - -DATETIME_OFFSETS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#DatetimeOffsetsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -DATETIME_OFFSETS = Schema( - id=ShapeID("aws.protocoltests.query#DatetimeOffsets"), - shape_type=ShapeType.OPERATION, -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#EmptyInputAndEmptyOutputInput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#EmptyInputAndEmptyOutputOutput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.query#EmptyInputAndEmptyOutput"), - shape_type=ShapeType.OPERATION, -) - -ENDPOINT_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#EndpointOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#EndpointOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION = Schema( - id=ShapeID("aws.protocoltests.query#EndpointOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo."}), - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#EndpointWithHostLabelOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#HostLabelInput", - ) - ], - members={ - "label": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#EndpointWithHostLabelOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.query#EndpointWithHostLabelOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo.{label}."}), - ) - ], -) - -FLATTENED_XML_MAP_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -FOO_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, -) - -FOO_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": FOO_ENUM}}, -) - -FLATTENED_XML_MAP_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapOutput"), - members={ - "myMap": { - "target": FOO_ENUM_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - } - }, -) - -FLATTENED_XML_MAP = Schema( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMap"), - shape_type=ShapeType.OPERATION, -) - -FLATTENED_XML_MAP_WITH_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNameOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="K")], - }, - "value": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="V")], - }, - }, -) - -FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNameOutput"), - members={ - "myMap": { - "target": FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - } - }, -) -FLATTENED_XML_MAP_WITH_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlName"), - shape_type=ShapeType.OPERATION, +n0 = "aws.protocoltests.query" +_DOI = "DatetimeOffsetsInput" +_sSI = "smithy.synthetic#originalShapeId" +_sU = "smithy.api#Unit" +n1 = "aws.protocoltests.shared" +_DT = "DateTime" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_DOO = "DatetimeOffsetsOutput" +_d = "datetime" +_DO = "DatetimeOffsets" +_EIAEOI = "EmptyInputAndEmptyOutputInput" +_EIAEOO = "EmptyInputAndEmptyOutputOutput" +_EIAEO = "EmptyInputAndEmptyOutput" +_EOI = "EndpointOperationInput" +_EOO = "EndpointOperationOutput" +_EO = "EndpointOperation" +_s = "smithy.api#endpoint" +_EWHLOI = "EndpointWithHostLabelOperationInput" +_aHLI = "aws.protocoltests.query#HostLabelInput" +_l = "label" +_sL = "smithy.api#hostLabel" +_sm = "smithy.api#required" +_EWHLOO = "EndpointWithHostLabelOperationOutput" +_EWHLO = "EndpointWithHostLabelOperation" +_FXMI = "FlattenedXmlMapInput" +_FE = "FooEnum" +_FOO = "FOO" +_BAZ = "BAZ" +_BAR = "BAR" +_ONE = "ONE" +_ZERO = "ZERO" +_FEM = "FooEnumMap" +_k = "key" +_v = "value" +_FXMO = "FlattenedXmlMapOutput" +_mM = "myMap" +_sFm = "smithy.api#xmlFlattened" +_FXM = "FlattenedXmlMap" +_FXMWXNI = "FlattenedXmlMapWithXmlNameInput" +_FXMWXNOM = "FlattenedXmlMapWithXmlNameOutputMap" +_sN = "smithy.api#xmlName" +_K = "K" +_V = "V" +_FXMWXNO = "FlattenedXmlMapWithXmlNameOutput" +_KVP = "KVP" +_FXMWXN = "FlattenedXmlMapWithXmlName" +_FXMWXNIl = "FlattenedXmlMapWithXmlNamespaceInput" +_FXMWXNOMl = "FlattenedXmlMapWithXmlNamespaceOutputMap" +_sNm = "smithy.api#xmlNamespace" +_FXMWXNOl = "FlattenedXmlMapWithXmlNamespaceOutput" +_FXMWXNl = "FlattenedXmlMapWithXmlNamespace" +_FSI = "FractionalSecondsInput" +_FSO = "FractionalSecondsOutput" +_FS = "FractionalSeconds" +_CNED = "ComplexNestedErrorData" +_F = "Foo" +_CE = "ComplexError" +_smi = "smithy.api#error" +_c = "client" +_TL = "TopLevel" +_N = "Nested" +_CCE = "CustomCodeError" +_aQE = "aws.protocols#awsQueryError" +_M = "Message" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_g = "greeting" +_IG = "InvalidGreeting" +_GWE = "GreetingWithErrors" +_HWPOI = "HostWithPathOperationInput" +_HWPOO = "HostWithPathOperationOutput" +_HWPO = "HostWithPathOperation" +_IWXNI = "IgnoresWrappingXmlNameInput" +_IWXNO = "IgnoresWrappingXmlNameOutput" +_IM = "IgnoreMe" +_f = "foo" +_IWXN = "IgnoresWrappingXmlName" +_NSO = "NestedStructuresOutput" +_NIANOI = "NoInputAndNoOutputInput" +_NIANOO = "NoInputAndNoOutputOutput" +_NIANO = "NoInputAndNoOutput" +_NIAOI = "NoInputAndOutputInput" +_NIAOO = "NoInputAndOutputOutput" +_NIAO = "NoInputAndOutput" +_PWCEI = "PutWithContentEncodingInput" +_e = "encoding" +_sH = "smithy.api#httpHeader" +_CE_ = "Content-Encoding" +_da = "data" +_PWCEO = "PutWithContentEncodingOutput" +_PWCE = "PutWithContentEncoding" +_sC = "smithy.api#requestCompression" +_QITAFI = "QueryIdempotencyTokenAutoFillInput" +_t = "token" +_sT = "smithy.api#idempotencyToken" +_QITAFO = "QueryIdempotencyTokenAutoFillOutput" +_QITAF = "QueryIdempotencyTokenAutoFill" +_GS = "GreetingStruct" +_h = "hi" +_GL = "GreetingList" +_m = "member" +_SL = "StringList" +_LWXN = "ListWithXmlName" +_i = "item" +_NSWL = "NestedStructWithList" +_LA = "ListArg" +_QLI = "QueryListsInput" +_CLA = "ComplexListArg" +_FLA = "FlattenedListArg" +_LAWXNM = "ListArgWithXmlNameMember" +_FLAWXN = "FlattenedListArgWithXmlName" +_H = "Hi" +_NWL = "NestedWithList" +_QLO = "QueryListsOutput" +_QL = "QueryLists" +_CM = "ComplexMap" +_SM = "StringMap" +_MWXN = "MapWithXmlName" +_MOL = "MapOfLists" +_NSWM = "NestedStructWithMap" +_MA = "MapArg" +_QMI = "QueryMapsInput" +_RMA = "RenamedMapArg" +_CMA = "ComplexMapArg" +_MWXMN = "MapWithXmlMemberName" +_FM = "FlattenedMap" +_FMWXN = "FlattenedMapWithXmlName" +_QMO = "QueryMapsOutput" +_QM = "QueryMaps" +_ES = "EpochSeconds" +_es = "epoch-seconds" +_QTI = "QueryTimestampsInput" +_nF = "normalFormat" +_eM = "epochMember" +_eT = "epochTarget" +_QTO = "QueryTimestampsOutput" +_QT = "QueryTimestamps" +_RXSI = "RecursiveXmlShapesInput" +_IE = "IntegerEnum" +_A = "A" +_B = "B" +_C = "C" +_SIPI = "SimpleInputParamsInput" +_Ba = "Bar" +_Baz = "Baz" +_Bam = "Bam" +_FV = "FloatValue" +_Bo = "Boo" +_Q = "Qux" +_SIPO = "SimpleInputParamsOutput" +_SIP = "SimpleInputParams" +_SSXPI = "SimpleScalarXmlPropertiesInput" +_SSXPO = "SimpleScalarXmlPropertiesOutput" +_sV = "stringValue" +_eSV = "emptyStringValue" +_tBV = "trueBooleanValue" +_fBV = "falseBooleanValue" +_bV = "byteValue" +_sVh = "shortValue" +_iV = "integerValue" +_lV = "longValue" +_fV = "floatValue" +_dV = "doubleValue" +_DD = "DoubleDribble" +_SSXP = "SimpleScalarXmlProperties" +_XBI = "XmlBlobsInput" +_XBOO = "XmlBlobsOperationOutput" +_aXBO = "aws.protocoltests.query#XmlBlobsOutput" +_XB = "XmlBlobs" +_XEBI = "XmlEmptyBlobsInput" +_XEBO = "XmlEmptyBlobsOutput" +_XEB = "XmlEmptyBlobs" +_XELI = "XmlEmptyListsInput" +_BL = "BooleanList" +_FEL = "FooEnumList" +_RLM = "RenamedListMembers" +_LWMN = "ListWithMemberNamespace" +_LWN = "ListWithNamespace" +_IL = "IntegerList" +_IEL = "IntegerEnumList" +_NSL = "NestedStringList" +_SS = "StringSet" +_SLM = "StructureListMember" +_a = "a" +_b = "b" +_o = "other" +_SLt = "StructureList" +_TLi = "TimestampList" +_XELO = "XmlEmptyListsOutput" +_aXLO = "aws.protocoltests.query#XmlListsOutput" +_sLt = "stringList" +_sS = "stringSet" +_iL = "integerList" +_bL = "booleanList" +_tL = "timestampList" +_eL = "enumList" +_iEL = "intEnumList" +_nSL = "nestedStringList" +_rLM = "renamedListMembers" +_r = "renamed" +_fL = "flattenedList" +_fLl = "flattenedList2" +_cN = "customName" +_fLWMN = "flattenedListWithMemberNamespace" +_fLWN = "flattenedListWithNamespace" +_sLtr = "structureList" +_mSL = "myStructureList" +_XEL = "XmlEmptyLists" +_XEMI = "XmlEmptyMapsInput" +_XMOM = "XmlMapsOutputMap" +_XEMO = "XmlEmptyMapsOutput" +_aXMO = "aws.protocoltests.query#XmlMapsOutput" +_XEM = "XmlEmptyMaps" +_XEI = "XmlEnumsInput" +_FES = "FooEnumSet" +_XEO = "XmlEnumsOutput" +_fE = "fooEnum1" +_fEo = "fooEnum2" +_fEoo = "fooEnum3" +_fEL = "fooEnumList" +_fES = "fooEnumSet" +_fEM = "fooEnumMap" +_XE = "XmlEnums" +_XIEI = "XmlIntEnumsInput" +_IEM = "IntegerEnumMap" +_IES = "IntegerEnumSet" +_XIEO = "XmlIntEnumsOutput" +_iE = "intEnum1" +_iEn = "intEnum2" +_iEnt = "intEnum3" +_iES = "intEnumSet" +_iEM = "intEnumMap" +_XIE = "XmlIntEnums" +_XLI = "XmlListsInput" +_XLOO = "XmlListsOperationOutput" +_XL = "XmlLists" +_XMI = "XmlMapsInput" +_XMOO = "XmlMapsOperationOutput" +_XM = "XmlMaps" +_XMXNI = "XmlMapsXmlNameInput" +_XMXNOM = "XmlMapsXmlNameOutputMap" +_At = "Attribute" +_S = "Setting" +_XMXNO = "XmlMapsXmlNameOutput" +_XMXN = "XmlMapsXmlName" +_XNI = "XmlNamespacesInput" +_XNL = "XmlNamespacedList" +_XNN = "XmlNamespaceNested" +_va = "values" +_XNO = "XmlNamespacesOutput" +_n = "nested" +_XN = "XmlNamespaces" +_XTI = "XmlTimestampsInput" +_HD = "HttpDate" +_hd = "http-date" +_XTO = "XmlTimestampsOutput" +_no = "normal" +_dT = "dateTime" +_dTOT = "dateTimeOnTarget" +_eS = "epochSeconds" +_eSOT = "epochSecondsOnTarget" +_hD = "httpDate" +_hDOT = "httpDateOnTarget" +_XT = "XmlTimestamps" +_SA = "StructArg" +_SAt = "StringArg" +_OA = "OtherArg" +_RA = "RecursiveArg" +_NSI = "NestedStructuresInput" +_RXSON = "RecursiveXmlShapesOutputNested1" +_RXSONe = "RecursiveXmlShapesOutputNested2" +_ba = "bar" +_rM = "recursiveMember" +_NS = "NestedStructures" +_RXSO = "RecursiveXmlShapesOutput" +_RXS = "RecursiveXmlShapes" +_AQ = "AwsQuery" +_aw = "aws.auth#sigv4" +_aQ = "aws.protocols#awsQuery" +_sB = "smithy.rules#endpointBdd" +_aws = "aws.api#service" + +DATETIME_OFFSETS_INPUT = (18, n0, _DOI, {_sSI: _sU}) + +DATE_TIME = (4, n1, _DT, {_sF: _dt}) + +DATETIME_OFFSETS_OUTPUT = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) + +DATETIME_OFFSETS = (23, n0, _DO, 0, DATETIME_OFFSETS_INPUT, DATETIME_OFFSETS_OUTPUT, ()) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n0, _EIAEOI, 0) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n0, _EIAEOO, 0) + +EMPTY_INPUT_AND_EMPTY_OUTPUT = ( + 23, + n0, + _EIAEO, + 0, + EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, + EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + (), +) + +ENDPOINT_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) + +ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) + +ENDPOINT_OPERATION = ( + 23, + n0, + _EO, + {_s: MappingProxyType({"hostPrefix": "foo."})}, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( + 18, + n0, + _EWHLOI, + {_sSI: _aHLI}, + (_l,), + ((3, 257),), +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) + +ENDPOINT_WITH_HOST_LABEL_OPERATION = ( + 23, + n0, + _EWHLO, + {_s: MappingProxyType({"hostPrefix": "foo.{label}."})}, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), +) + +FLATTENED_XML_MAP_INPUT = (18, n0, _FXMI, {_sSI: _sU}) + +FOO_ENUM = ( + 14, + n1, + _FE, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +FOO_ENUM_MAP = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) + +FLATTENED_XML_MAP_OUTPUT = (18, n0, _FXMO, 0, (_mM,), ((FOO_ENUM_MAP, {_sFm: None}),)) + +FLATTENED_XML_MAP = ( + 23, + n0, + _FXM, + 0, + FLATTENED_XML_MAP_INPUT, + FLATTENED_XML_MAP_OUTPUT, + (), +) + +FLATTENED_XML_MAP_WITH_XML_NAME_INPUT = (18, n0, _FXMWXNI, {_sSI: _sU}) + +FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP = ( + 17, + n0, + _FXMWXNOM, + 0, + (_k, _v), + ((3, {_sN: _K}), (3, {_sN: _V})), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNamespaceInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT = ( + 18, + n0, + _FXMWXNO, + 0, + (_mM,), + ((FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP, {_sN: _KVP, _sFm: None}),), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNamespaceOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="K"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-key.example.com"}), - ), - ], - }, - "value": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="V"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-value.example.com"}), - ), - ], - }, - }, -) - -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNamespaceOutput"), - members={ - "myMap": { - "target": FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-member.example.com"}), - ), - ], - } - }, -) - -FLATTENED_XML_MAP_WITH_XML_NAMESPACE = Schema( - id=ShapeID("aws.protocoltests.query#FlattenedXmlMapWithXmlNamespace"), - shape_type=ShapeType.OPERATION, -) - -FRACTIONAL_SECONDS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FractionalSecondsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -FRACTIONAL_SECONDS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#FractionalSecondsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -FRACTIONAL_SECONDS = Schema( - id=ShapeID("aws.protocoltests.query#FractionalSeconds"), - shape_type=ShapeType.OPERATION, -) - -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("aws.protocoltests.query#ComplexNestedErrorData"), - members={"Foo": {"target": STRING}}, -) - -COMPLEX_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.query#ComplexError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, -) - -CUSTOM_CODE_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.query#CustomCodeError"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new( - id=ShapeID("aws.protocols#awsQueryError"), - value=MappingProxyType({"code": "Customized", "httpResponseCode": 402}), +FLATTENED_XML_MAP_WITH_XML_NAME = ( + 23, + n0, + _FXMWXN, + 0, + FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, + FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, + (), +) + +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT = (18, n0, _FXMWXNIl, {_sSI: _sU}) + +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP = ( + 17, + n0, + _FXMWXNOMl, + 0, + (_k, _v), + ( + (3, {_sN: _K, _sNm: MappingProxyType({"uri": "https://the-key.example.com"})}), + ( + 3, + {_sN: _V, _sNm: MappingProxyType({"uri": "https://the-value.example.com"})}, ), - ], - members={"Message": {"target": STRING}}, -) - -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#GreetingWithErrorsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#GreetingWithErrorsOutput"), - members={"greeting": {"target": STRING}}, -) - -INVALID_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.query#InvalidGreeting"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={"Message": {"target": STRING}}, -) - -GREETING_WITH_ERRORS = Schema( - id=ShapeID("aws.protocoltests.query#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, -) - -HOST_WITH_PATH_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#HostWithPathOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HOST_WITH_PATH_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#HostWithPathOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HOST_WITH_PATH_OPERATION = Schema( - id=ShapeID("aws.protocoltests.query#HostWithPathOperation"), - shape_type=ShapeType.OPERATION, -) - -IGNORES_WRAPPING_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#IgnoresWrappingXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -IGNORES_WRAPPING_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#IgnoresWrappingXmlNameOutput"), - traits=[Trait.new(id=ShapeID("smithy.api#xmlName"), value="IgnoreMe")], - members={"foo": {"target": STRING}}, -) - -IGNORES_WRAPPING_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.query#IgnoresWrappingXmlName"), - shape_type=ShapeType.OPERATION, -) - -NESTED_STRUCTURES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#NestedStructuresOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_NO_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#NoInputAndNoOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_NO_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#NoInputAndNoOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], + ), +) + +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT = ( + 18, + n0, + _FXMWXNOl, + 0, + (_mM,), + ( + ( + FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP, + { + _sN: _KVP, + _sFm: None, + _sNm: MappingProxyType({"uri": "https://the-member.example.com"}), + }, + ), + ), ) -NO_INPUT_AND_NO_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.query#NoInputAndNoOutput"), - shape_type=ShapeType.OPERATION, +FLATTENED_XML_MAP_WITH_XML_NAMESPACE = ( + 23, + n0, + _FXMWXNl, + 0, + FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, + FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, + (), ) -NO_INPUT_AND_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#NoInputAndOutputInput") -) +FRACTIONAL_SECONDS_INPUT = (18, n0, _FSI, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#NoInputAndOutputOutput") -) +FRACTIONAL_SECONDS_OUTPUT = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -NO_INPUT_AND_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.query#NoInputAndOutput"), - shape_type=ShapeType.OPERATION, +FRACTIONAL_SECONDS = ( + 23, + n0, + _FS, + 0, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#PutWithContentEncodingInput"), - members={ - "encoding": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Encoding") - ], - }, - "data": {"target": STRING}, - }, -) +COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, 0),)) -PUT_WITH_CONTENT_ENCODING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#PutWithContentEncodingOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +COMPLEX_ERROR = ( + 18, + n0, + _CE, + {_smi: _c}, + (_TL, _N), + ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -PUT_WITH_CONTENT_ENCODING = Schema( - id=ShapeID("aws.protocoltests.query#PutWithContentEncoding"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#requestCompression"), - value=MappingProxyType({"encodings": ("gzip",)}), - ) - ], +CUSTOM_CODE_ERROR = ( + 18, + n0, + _CCE, + {_smi: _c, _aQE: MappingProxyType({"code": "Customized", "httpResponseCode": 402})}, + (_M,), + ((3, 0),), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryIdempotencyTokenAutoFillInput"), - members={ - "token": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#idempotencyToken"))], - } - }, -) +GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, {_sSI: _sU}) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryIdempotencyTokenAutoFillOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = Schema( - id=ShapeID("aws.protocoltests.query#QueryIdempotencyTokenAutoFill"), - shape_type=ShapeType.OPERATION, -) +INVALID_GREETING = (18, n0, _IG, {_smi: _c}, (_M,), ((3, 0),)) -GREETING_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, +GREETING_WITH_ERRORS = ( + 23, + n0, + _GWE, + 0, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR, CUSTOM_CODE_ERROR), ) -GREETING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GREETING_STRUCT}}, -) +HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) -STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) +HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) -LIST_WITH_XML_NAME = Schema.collection( - id=ShapeID("aws.protocoltests.query#ListWithXmlName"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, +HOST_WITH_PATH_OPERATION = ( + 23, + n0, + _HWPO, + 0, + HOST_WITH_PATH_OPERATION_INPUT, + HOST_WITH_PATH_OPERATION_OUTPUT, + (), ) -NESTED_STRUCT_WITH_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.query#NestedStructWithList"), - members={"ListArg": {"target": STRING_LIST}}, -) +IGNORES_WRAPPING_XML_NAME_INPUT = (18, n0, _IWXNI, {_sSI: _sU}) -QUERY_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryListsInput"), - members={ - "ListArg": {"target": STRING_LIST}, - "ComplexListArg": {"target": GREETING_LIST}, - "FlattenedListArg": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "ListArgWithXmlNameMember": {"target": LIST_WITH_XML_NAME}, - "FlattenedListArgWithXmlName": { - "target": LIST_WITH_XML_NAME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="Hi"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "NestedWithList": {"target": NESTED_STRUCT_WITH_LIST}, - }, -) +IGNORES_WRAPPING_XML_NAME_OUTPUT = (18, n0, _IWXNO, {_sN: _IM}, (_f,), ((3, 0),)) -QUERY_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +IGNORES_WRAPPING_XML_NAME = ( + 23, + n0, + _IWXN, + 0, + IGNORES_WRAPPING_XML_NAME_INPUT, + IGNORES_WRAPPING_XML_NAME_OUTPUT, + (), ) -QUERY_LISTS = Schema( - id=ShapeID("aws.protocoltests.query#QueryLists"), shape_type=ShapeType.OPERATION -) +NESTED_STRUCTURES_OUTPUT = (18, n0, _NSO, {_sSI: _sU}) -COMPLEX_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.query#ComplexMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, -) +NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n0, _NIANOI, {_sSI: _sU}) -STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) +NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n0, _NIANOO, {_sSI: _sU}) -MAP_WITH_XML_NAME = Schema.collection( - id=ShapeID("aws.protocoltests.query#MapWithXmlName"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="K")], - }, - "value": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="V")], - }, - }, +NO_INPUT_AND_NO_OUTPUT = ( + 23, + n0, + _NIANO, + 0, + NO_INPUT_AND_NO_OUTPUT_INPUT, + NO_INPUT_AND_NO_OUTPUT_OUTPUT, + (), ) -MAP_OF_LISTS = Schema.collection( - id=ShapeID("aws.protocoltests.query#MapOfLists"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING_LIST}}, -) +NO_INPUT_AND_OUTPUT_INPUT = (18, n0, _NIAOI, 0) -NESTED_STRUCT_WITH_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.query#NestedStructWithMap"), - members={"MapArg": {"target": STRING_MAP}}, -) +NO_INPUT_AND_OUTPUT_OUTPUT = (18, n0, _NIAOO, 0) -QUERY_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryMapsInput"), - members={ - "MapArg": {"target": STRING_MAP}, - "RenamedMapArg": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="Foo")], - }, - "ComplexMapArg": {"target": COMPLEX_MAP}, - "MapWithXmlMemberName": {"target": MAP_WITH_XML_NAME}, - "FlattenedMap": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "FlattenedMapWithXmlName": { - "target": MAP_WITH_XML_NAME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="Hi"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "MapOfLists": {"target": MAP_OF_LISTS}, - "NestedStructWithMap": {"target": NESTED_STRUCT_WITH_MAP}, - }, +NO_INPUT_AND_OUTPUT = ( + 23, + n0, + _NIAO, + 0, + NO_INPUT_AND_OUTPUT_INPUT, + NO_INPUT_AND_OUTPUT_OUTPUT, + (), ) -QUERY_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +PUT_WITH_CONTENT_ENCODING_INPUT = ( + 18, + n0, + _PWCEI, + 0, + (_e, _da), + ((3, {_sH: _CE_}), (3, 0)), ) -QUERY_MAPS = Schema( - id=ShapeID("aws.protocoltests.query#QueryMaps"), shape_type=ShapeType.OPERATION -) +PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) -EPOCH_SECONDS = Schema( - id=ShapeID("aws.protocoltests.shared#EpochSeconds"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds")], +PUT_WITH_CONTENT_ENCODING = ( + 23, + n0, + _PWCE, + {_sC: MappingProxyType({"encodings": ("gzip",)})}, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), ) -QUERY_TIMESTAMPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryTimestampsInput"), - members={ - "normalFormat": {"target": TIMESTAMP}, - "epochMember": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochTarget": {"target": EPOCH_SECONDS}, - }, -) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = (18, n0, _QITAFI, 0, (_t,), ((3, 2),)) -QUERY_TIMESTAMPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#QueryTimestampsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n0, _QITAFO, {_sSI: _sU}) -QUERY_TIMESTAMPS = Schema( - id=ShapeID("aws.protocoltests.query#QueryTimestamps"), - shape_type=ShapeType.OPERATION, +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( + 23, + n0, + _QITAF, + 0, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + (), ) -RECURSIVE_XML_SHAPES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#RecursiveXmlShapesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) -INTEGER_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, -) +GREETING_LIST = (16, n1, _GL, 0, (_m,), ((GREETING_STRUCT, 0),)) -SIMPLE_INPUT_PARAMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#SimpleInputParamsInput"), - members={ - "Foo": {"target": STRING}, - "Bar": {"target": STRING}, - "Baz": {"target": BOOLEAN}, - "Bam": {"target": INTEGER}, - "FloatValue": {"target": FLOAT}, - "Boo": {"target": DOUBLE}, - "Qux": {"target": BLOB}, - "FooEnum": {"target": FOO_ENUM}, - "IntegerEnum": {"target": INTEGER_ENUM}, - }, -) +STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) -SIMPLE_INPUT_PARAMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#SimpleInputParamsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +LIST_WITH_XML_NAME = (16, n0, _LWXN, 0, (_m,), ((3, {_sN: _i}),)) -SIMPLE_INPUT_PARAMS = Schema( - id=ShapeID("aws.protocoltests.query#SimpleInputParams"), - shape_type=ShapeType.OPERATION, -) +NESTED_STRUCT_WITH_LIST = (18, n0, _NSWL, 0, (_LA,), ((STRING_LIST, 0),)) -SIMPLE_SCALAR_XML_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#SimpleScalarXmlPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +QUERY_LISTS_INPUT = ( + 18, + n0, + _QLI, + 0, + (_LA, _CLA, _FLA, _LAWXNM, _FLAWXN, _NWL), + ( + (STRING_LIST, 0), + (GREETING_LIST, 0), + (STRING_LIST, {_sFm: None}), + (LIST_WITH_XML_NAME, 0), + (LIST_WITH_XML_NAME, {_sN: _H, _sFm: None}), + (NESTED_STRUCT_WITH_LIST, 0), + ), ) -SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#SimpleScalarXmlPropertiesOutput"), - members={ - "stringValue": {"target": STRING}, - "emptyStringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="DoubleDribble") - ], - }, - }, -) +QUERY_LISTS_OUTPUT = (18, n0, _QLO, {_sSI: _sU}) -SIMPLE_SCALAR_XML_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.query#SimpleScalarXmlProperties"), - shape_type=ShapeType.OPERATION, -) +QUERY_LISTS = (23, n0, _QL, 0, QUERY_LISTS_INPUT, QUERY_LISTS_OUTPUT, ()) -XML_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +COMPLEX_MAP = (17, n0, _CM, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) -XML_BLOBS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlBlobsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#XmlBlobsOutput", - ) - ], - members={"data": {"target": BLOB}}, -) +STRING_MAP = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -XML_BLOBS = Schema( - id=ShapeID("aws.protocoltests.query#XmlBlobs"), shape_type=ShapeType.OPERATION -) +MAP_WITH_XML_NAME = (17, n0, _MWXN, 0, (_k, _v), ((3, {_sN: _K}), (3, {_sN: _V}))) -XML_EMPTY_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEmptyBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +MAP_OF_LISTS = (17, n0, _MOL, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) -XML_EMPTY_BLOBS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEmptyBlobsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#XmlBlobsOutput", - ) - ], - members={"data": {"target": BLOB}}, +NESTED_STRUCT_WITH_MAP = (18, n0, _NSWM, 0, (_MA,), ((STRING_MAP, 0),)) + +QUERY_MAPS_INPUT = ( + 18, + n0, + _QMI, + 0, + (_MA, _RMA, _CMA, _MWXMN, _FM, _FMWXN, _MOL, _NSWM), + ( + (STRING_MAP, 0), + (STRING_MAP, {_sN: _F}), + (COMPLEX_MAP, 0), + (MAP_WITH_XML_NAME, 0), + (STRING_MAP, {_sFm: None}), + (MAP_WITH_XML_NAME, {_sN: _H, _sFm: None}), + (MAP_OF_LISTS, 0), + (NESTED_STRUCT_WITH_MAP, 0), + ), ) -XML_EMPTY_BLOBS = Schema( - id=ShapeID("aws.protocoltests.query#XmlEmptyBlobs"), shape_type=ShapeType.OPERATION -) +QUERY_MAPS_OUTPUT = (18, n0, _QMO, {_sSI: _sU}) -XML_EMPTY_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEmptyListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +QUERY_MAPS = (23, n0, _QM, 0, QUERY_MAPS_INPUT, QUERY_MAPS_OUTPUT, ()) -BOOLEAN_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#BooleanList"), - shape_type=ShapeType.LIST, - members={"member": {"target": BOOLEAN}}, -) +EPOCH_SECONDS = (4, n1, _ES, {_sF: _es}) -FOO_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, +QUERY_TIMESTAMPS_INPUT = ( + 18, + n0, + _QTI, + 0, + (_nF, _eM, _eT), + ((4, 0), (4, {_sF: _es}), (EPOCH_SECONDS, 0)), ) -RENAMED_LIST_MEMBERS = Schema.collection( - id=ShapeID("aws.protocoltests.query#RenamedListMembers"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, -) +QUERY_TIMESTAMPS_OUTPUT = (18, n0, _QTO, {_sSI: _sU}) -LIST_WITH_MEMBER_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.query#ListWithMemberNamespace"), - shape_type=ShapeType.LIST, - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-list.example.com"}), - ) - ], - members={ - "member": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-member.example.com"}), - ) - ], - } - }, -) +QUERY_TIMESTAMPS = (23, n0, _QT, 0, QUERY_TIMESTAMPS_INPUT, QUERY_TIMESTAMPS_OUTPUT, ()) -LIST_WITH_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.query#ListWithNamespace"), - shape_type=ShapeType.LIST, - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-list.example.com"}), - ) - ], - members={"member": {"target": STRING}}, -) +RECURSIVE_XML_SHAPES_INPUT = (18, n0, _RXSI, {_sSI: _sU}) -INTEGER_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) +INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -INTEGER_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, +SIMPLE_INPUT_PARAMS_INPUT = ( + 18, + n0, + _SIPI, + 0, + (_F, _Ba, _Baz, _Bam, _FV, _Bo, _Q, _FE, _IE), + ( + (3, 0), + (3, 0), + (2, 0), + (7, 0), + (9, 0), + (10, 0), + (1, 0), + (FOO_ENUM, 0), + (INTEGER_ENUM, 0), + ), ) -NESTED_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#NestedStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING_LIST}}, -) - -STRING_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -STRUCTURE_LIST_MEMBER = Schema.collection( - id=ShapeID("aws.protocoltests.query#StructureListMember"), - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="value")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="other")], - }, - }, -) - -STRUCTURE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.query#StructureList"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRUCTURE_LIST_MEMBER, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, -) - -TIMESTAMP_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#TimestampList"), - shape_type=ShapeType.LIST, - members={"member": {"target": TIMESTAMP}}, -) - -XML_EMPTY_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEmptyListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#XmlListsOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - }, -) +SIMPLE_INPUT_PARAMS_OUTPUT = (18, n0, _SIPO, {_sSI: _sU}) -XML_EMPTY_LISTS = Schema( - id=ShapeID("aws.protocoltests.query#XmlEmptyLists"), shape_type=ShapeType.OPERATION +SIMPLE_INPUT_PARAMS = ( + 23, + n0, + _SIP, + 0, + SIMPLE_INPUT_PARAMS_INPUT, + SIMPLE_INPUT_PARAMS_OUTPUT, + (), ) -XML_EMPTY_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEmptyMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +SIMPLE_SCALAR_XML_PROPERTIES_INPUT = (18, n0, _SSXPI, {_sSI: _sU}) -XML_MAPS_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlMapsOutputMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, +SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT = ( + 18, + n0, + _SSXPO, + 0, + (_sV, _eSV, _tBV, _fBV, _bV, _sVh, _iV, _lV, _fV, _dV), + ( + (3, 0), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_sN: _DD}), + ), ) -XML_EMPTY_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEmptyMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#XmlMapsOutput", - ) - ], - members={"myMap": {"target": XML_MAPS_OUTPUT_MAP}}, +SIMPLE_SCALAR_XML_PROPERTIES = ( + 23, + n0, + _SSXP, + 0, + SIMPLE_SCALAR_XML_PROPERTIES_INPUT, + SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, + (), ) -XML_EMPTY_MAPS = Schema( - id=ShapeID("aws.protocoltests.query#XmlEmptyMaps"), shape_type=ShapeType.OPERATION -) +XML_BLOBS_INPUT = (18, n0, _XBI, {_sSI: _sU}) -XML_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +XML_BLOBS_OPERATION_OUTPUT = (18, n0, _XBOO, {_sSI: _aXBO}, (_da,), ((1, 0),)) -FOO_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) +XML_BLOBS = (23, n0, _XB, 0, XML_BLOBS_INPUT, XML_BLOBS_OPERATION_OUTPUT, ()) -XML_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlEnumsOutput"), - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, -) +XML_EMPTY_BLOBS_INPUT = (18, n0, _XEBI, {_sSI: _sU}) -XML_ENUMS = Schema( - id=ShapeID("aws.protocoltests.query#XmlEnums"), shape_type=ShapeType.OPERATION -) +XML_EMPTY_BLOBS_OUTPUT = (18, n0, _XEBO, {_sSI: _aXBO}, (_da,), ((1, 0),)) -XML_INT_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlIntEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +XML_EMPTY_BLOBS = (23, n0, _XEB, 0, XML_EMPTY_BLOBS_INPUT, XML_EMPTY_BLOBS_OUTPUT, ()) -INTEGER_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER_ENUM}}, -) +XML_EMPTY_LISTS_INPUT = (18, n0, _XELI, {_sSI: _sU}) -INTEGER_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) - -XML_INT_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlIntEnumsOutput"), - members={ - "intEnum1": {"target": INTEGER_ENUM}, - "intEnum2": {"target": INTEGER_ENUM}, - "intEnum3": {"target": INTEGER_ENUM}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "intEnumSet": {"target": INTEGER_ENUM_SET}, - "intEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -XML_INT_ENUMS = Schema( - id=ShapeID("aws.protocoltests.query#XmlIntEnums"), shape_type=ShapeType.OPERATION -) - -XML_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -XML_LISTS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlListsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#XmlListsOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - }, -) - -XML_LISTS = Schema( - id=ShapeID("aws.protocoltests.query#XmlLists"), shape_type=ShapeType.OPERATION -) - -XML_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -XML_MAPS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlMapsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.query#XmlMapsOutput", - ) - ], - members={"myMap": {"target": XML_MAPS_OUTPUT_MAP}}, -) - -XML_MAPS = Schema( - id=ShapeID("aws.protocoltests.query#XmlMaps"), shape_type=ShapeType.OPERATION -) - -XML_MAPS_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlMapsXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -XML_MAPS_XML_NAME_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlMapsXmlNameOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="Attribute")], - }, - "value": { - "target": GREETING_STRUCT, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="Setting")], - }, - }, -) +BOOLEAN_LIST = (16, n1, _BL, 0, (_m,), ((2, 0),)) -XML_MAPS_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlMapsXmlNameOutput"), - members={"myMap": {"target": XML_MAPS_XML_NAME_OUTPUT_MAP}}, -) +FOO_ENUM_LIST = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -XML_MAPS_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.query#XmlMapsXmlName"), shape_type=ShapeType.OPERATION -) +RENAMED_LIST_MEMBERS = (16, n0, _RLM, 0, (_m,), ((3, {_sN: _i}),)) -XML_NAMESPACES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlNamespacesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +LIST_WITH_MEMBER_NAMESPACE = ( + 16, + n0, + _LWMN, + {_sNm: MappingProxyType({"uri": "https://xml-list.example.com"})}, + (_m,), + ((3, {_sNm: MappingProxyType({"uri": "https://xml-member.example.com"})}),), ) -XML_NAMESPACED_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlNamespacedList"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://bux.com"}), - ) - ], - } - }, +LIST_WITH_NAMESPACE = ( + 16, + n0, + _LWN, + {_sNm: MappingProxyType({"uri": "https://xml-list.example.com"})}, + (_m,), + ((3, 0),), ) -XML_NAMESPACE_NESTED = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlNamespaceNested"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://boo.com"}), - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://baz.com", "prefix": "baz"}), - ) - ], - }, - "values": { - "target": XML_NAMESPACED_LIST, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://qux.com"}), - ) - ], - }, - }, -) +INTEGER_LIST = (16, n1, _IL, 0, (_m,), ((7, 0),)) + +INTEGER_ENUM_LIST = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -XML_NAMESPACES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlNamespacesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ) - ], - members={"nested": {"target": XML_NAMESPACE_NESTED}}, -) +NESTED_STRING_LIST = (16, n1, _NSL, 0, (_m,), ((STRING_LIST, 0),)) -XML_NAMESPACES = Schema( - id=ShapeID("aws.protocoltests.query#XmlNamespaces"), shape_type=ShapeType.OPERATION -) +STRING_SET = (16, n1, _SS, 0, (_m,), ((3, 0),)) -XML_TIMESTAMPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlTimestampsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +STRUCTURE_LIST_MEMBER = (18, n0, _SLM, 0, (_a, _b), ((3, {_sN: _v}), (3, {_sN: _o}))) -HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.shared#HttpDate"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date")], -) +STRUCTURE_LIST = (16, n0, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, {_sN: _i}),)) -XML_TIMESTAMPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#XmlTimestampsOutput"), - members={ - "normal": {"target": TIMESTAMP}, - "dateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "dateTimeOnTarget": {"target": DATE_TIME}, - "epochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochSecondsOnTarget": {"target": EPOCH_SECONDS}, - "httpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "httpDateOnTarget": {"target": HTTP_DATE}, - }, -) +TIMESTAMP_LIST = (16, n1, _TLi, 0, (_m,), ((4, 0),)) -XML_TIMESTAMPS = Schema( - id=ShapeID("aws.protocoltests.query#XmlTimestamps"), shape_type=ShapeType.OPERATION -) +XML_EMPTY_LISTS_OUTPUT = ( + 18, + n0, + _XELO, + {_sSI: _aXLO}, + (_sLt, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _rLM, _fL, _fLl, _fLWMN, _fLWN, _sLtr), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + ), +) + +XML_EMPTY_LISTS = (23, n0, _XEL, 0, XML_EMPTY_LISTS_INPUT, XML_EMPTY_LISTS_OUTPUT, ()) -STRUCT_ARG = Schema.collection( - id=ShapeID("aws.protocoltests.query#StructArg"), - members={ - "StringArg": {"target": STRING}, - "OtherArg": {"target": BOOLEAN}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "RecursiveArg": None, - }, -) +XML_EMPTY_MAPS_INPUT = (18, n0, _XEMI, {_sSI: _sU}) -NESTED_STRUCTURES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#NestedStructuresInput"), - members={"Nested": {"target": STRUCT_ARG}}, -) +XML_MAPS_OUTPUT_MAP = (17, n0, _XMOM, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = Schema.collection( - id=ShapeID("aws.protocoltests.query#RecursiveXmlShapesOutputNested1"), - members={ - "foo": {"target": STRING}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "nested": None, - }, +XML_EMPTY_MAPS_OUTPUT = ( + 18, + n0, + _XEMO, + {_sSI: _aXMO}, + (_mM,), + ((XML_MAPS_OUTPUT_MAP, 0),), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = Schema.collection( - id=ShapeID("aws.protocoltests.query#RecursiveXmlShapesOutputNested2"), - members={ - "bar": {"target": STRING}, - "recursiveMember": {"target": RECURSIVE_XML_SHAPES_OUTPUT_NESTED1}, - }, -) +XML_EMPTY_MAPS = (23, n0, _XEM, 0, XML_EMPTY_MAPS_INPUT, XML_EMPTY_MAPS_OUTPUT, ()) -NESTED_STRUCTURES = Schema( - id=ShapeID("aws.protocoltests.query#NestedStructures"), - shape_type=ShapeType.OPERATION, -) +XML_ENUMS_INPUT = (18, n0, _XEI, {_sSI: _sU}) -RECURSIVE_XML_SHAPES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.query#RecursiveXmlShapesOutput"), - members={"nested": {"target": RECURSIVE_XML_SHAPES_OUTPUT_NESTED1}}, -) +FOO_ENUM_SET = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -RECURSIVE_XML_SHAPES = Schema( - id=ShapeID("aws.protocoltests.query#RecursiveXmlShapes"), - shape_type=ShapeType.OPERATION, +XML_ENUMS_OUTPUT = ( + 18, + n0, + _XEO, + 0, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -AWS_QUERY = Schema( - id=ShapeID("aws.protocoltests.query#AwsQuery"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), value=MappingProxyType({"name": "awsquery"}) - ), - Trait.new(id=ShapeID("aws.protocols#awsQuery")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( +XML_ENUMS = (23, n0, _XE, 0, XML_ENUMS_INPUT, XML_ENUMS_OUTPUT, ()) + +XML_INT_ENUMS_INPUT = (18, n0, _XIEI, {_sSI: _sU}) + +INTEGER_ENUM_MAP = (17, n1, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) + +INTEGER_ENUM_SET = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) + +XML_INT_ENUMS_OUTPUT = ( + 18, + n0, + _XIEO, + 0, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), +) + +XML_INT_ENUMS = (23, n0, _XIE, 0, XML_INT_ENUMS_INPUT, XML_INT_ENUMS_OUTPUT, ()) + +XML_LISTS_INPUT = (18, n0, _XLI, {_sSI: _sU}) + +XML_LISTS_OPERATION_OUTPUT = ( + 18, + n0, + _XLOO, + {_sSI: _aXLO}, + (_sLt, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _rLM, _fL, _fLl, _fLWMN, _fLWN, _sLtr), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + ), +) + +XML_LISTS = (23, n0, _XL, 0, XML_LISTS_INPUT, XML_LISTS_OPERATION_OUTPUT, ()) + +XML_MAPS_INPUT = (18, n0, _XMI, {_sSI: _sU}) + +XML_MAPS_OPERATION_OUTPUT = ( + 18, + n0, + _XMOO, + {_sSI: _aXMO}, + (_mM,), + ((XML_MAPS_OUTPUT_MAP, 0),), +) + +XML_MAPS = (23, n0, _XM, 0, XML_MAPS_INPUT, XML_MAPS_OPERATION_OUTPUT, ()) + +XML_MAPS_XML_NAME_INPUT = (18, n0, _XMXNI, {_sSI: _sU}) + +XML_MAPS_XML_NAME_OUTPUT_MAP = ( + 17, + n0, + _XMXNOM, + 0, + (_k, _v), + ((3, {_sN: _At}), (GREETING_STRUCT, {_sN: _S})), +) + +XML_MAPS_XML_NAME_OUTPUT = ( + 18, + n0, + _XMXNO, + 0, + (_mM,), + ((XML_MAPS_XML_NAME_OUTPUT_MAP, 0),), +) + +XML_MAPS_XML_NAME = ( + 23, + n0, + _XMXN, + 0, + XML_MAPS_XML_NAME_INPUT, + XML_MAPS_XML_NAME_OUTPUT, + (), +) + +XML_NAMESPACES_INPUT = (18, n0, _XNI, {_sSI: _sU}) + +XML_NAMESPACED_LIST = ( + 16, + n0, + _XNL, + 0, + (_m,), + ((3, {_sNm: MappingProxyType({"uri": "http://bux.com"})}),), +) + +XML_NAMESPACE_NESTED = ( + 18, + n0, + _XNN, + {_sNm: MappingProxyType({"uri": "http://boo.com"})}, + (_f, _va), + ( + (3, {_sNm: MappingProxyType({"uri": "http://baz.com", "prefix": "baz"})}), + (XML_NAMESPACED_LIST, {_sNm: MappingProxyType({"uri": "http://qux.com"})}), + ), +) + +XML_NAMESPACES_OUTPUT = ( + 18, + n0, + _XNO, + {_sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_n,), + ((XML_NAMESPACE_NESTED, 0),), +) + +XML_NAMESPACES = (23, n0, _XN, 0, XML_NAMESPACES_INPUT, XML_NAMESPACES_OUTPUT, ()) + +XML_TIMESTAMPS_INPUT = (18, n0, _XTI, {_sSI: _sU}) + +HTTP_DATE = (4, n1, _HD, {_sF: _hd}) + +XML_TIMESTAMPS_OUTPUT = ( + 18, + n0, + _XTO, + 0, + (_no, _dT, _dTOT, _eS, _eSOT, _hD, _hDOT), + ( + (4, 0), + (4, {_sF: _dt}), + (DATE_TIME, 0), + (4, {_sF: _es}), + (EPOCH_SECONDS, 0), + (4, {_sF: _hd}), + (HTTP_DATE, 0), + ), +) + +XML_TIMESTAMPS = (23, n0, _XT, 0, XML_TIMESTAMPS_INPUT, XML_TIMESTAMPS_OUTPUT, ()) + +STRUCT_ARG = ( + 18, + n0, + _SA, + 0, + (_SAt, _OA, _RA), + ((3, 0), (2, 0), (lambda: STRUCT_ARG, 0)), +) + +NESTED_STRUCTURES_INPUT = (18, n0, _NSI, 0, (_N,), ((STRUCT_ARG, 0),)) + +RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( + 18, + n0, + _RXSON, + 0, + (_f, _n), + ((3, 0), (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0)), +) + +RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( + 18, + n0, + _RXSONe, + 0, + (_ba, _rM), + ((3, 0), (RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0)), +) + +NESTED_STRUCTURES = ( + 23, + n0, + _NS, + 0, + NESTED_STRUCTURES_INPUT, + NESTED_STRUCTURES_OUTPUT, + (), +) + +RECURSIVE_XML_SHAPES_OUTPUT = ( + 18, + n0, + _RXSO, + 0, + (_n,), + ((RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_XML_SHAPES = ( + 23, + n0, + _RXS, + 0, + RECURSIVE_XML_SHAPES_INPUT, + RECURSIVE_XML_SHAPES_OUTPUT, + (), +) + +AWS_QUERY = ( + 21, + n0, + _AQ, + { + _aw: MappingProxyType({"name": "awsquery"}), + _aQ: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://awsquery-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://awsquery.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://awsquery-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://awsquery.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://awsquery.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), - ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType({"sdkId": "Query Protocol"}), - ), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://example.com/"}), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsquery-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsquery.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsquery-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsquery.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsquery.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - ], -) - -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["nested"] = Schema.member( - id=RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.id.with_member("nested"), - target=RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, - index=1, -) - -STRUCT_ARG.members["RecursiveArg"] = Schema.member( - id=STRUCT_ARG.id.with_member("RecursiveArg"), target=STRUCT_ARG, index=2 + _aws: MappingProxyType({"sdkId": "Query Protocol"}), + _sNm: MappingProxyType({"uri": "https://example.com/"}), + }, ) diff --git a/codegen-output/aws-query/src/awsquery/models.py b/codegen-output/aws-query/src/awsquery/models.py index ba02f0cbf..f7e6b0a8c 100644 --- a/codegen-output/aws-query/src/awsquery/models.py +++ b/codegen-output/aws-query/src/awsquery/models.py @@ -6,6 +6,7 @@ import logging from typing import Any, Literal, Self +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import TypeRegistry from smithy_core.exceptions import ModeledError @@ -147,7 +148,7 @@ class DatetimeOffsetsInput: """Dataclass for DatetimeOffsetsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -159,13 +160,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -186,13 +188,12 @@ class DatetimeOffsetsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -201,30 +202,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DATETIME_OFFSETS = APIOperation( input=DatetimeOffsetsInput, output=DatetimeOffsetsOutput, - schema=_SCHEMA_DATETIME_OFFSETS, - input_schema=_SCHEMA_DATETIME_OFFSETS_INPUT, - output_schema=_SCHEMA_DATETIME_OFFSETS_OUTPUT, + static_schema=_SCHEMA_DATETIME_OFFSETS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -233,7 +231,9 @@ class EmptyInputAndEmptyOutputInput: """Dataclass for EmptyInputAndEmptyOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -245,15 +245,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -272,7 +271,9 @@ class EmptyInputAndEmptyOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -284,27 +285,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_INPUT_AND_EMPTY_OUTPUT = APIOperation( input=EmptyInputAndEmptyOutputInput, output=EmptyInputAndEmptyOutputOutput, - schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, - input_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, - output_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + static_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -313,7 +310,7 @@ class EndpointOperationInput: """Dataclass for EndpointOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -325,13 +322,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -350,7 +348,7 @@ class EndpointOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -362,25 +360,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_OPERATION = APIOperation( input=EndpointOperationInput, output=EndpointOperationOutput, - schema=_SCHEMA_ENDPOINT_OPERATION, - input_schema=_SCHEMA_ENDPOINT_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -391,14 +387,16 @@ class EndpointWithHostLabelOperationInput: label: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT + ).members_by_index if self.label is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members["label"], - self.label, - ) + serializer.write_string(members[0], self.label) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -407,22 +405,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["label"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members[ - "label" - ] - ) + kwargs["label"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -441,7 +435,9 @@ class EndpointWithHostLabelOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -453,27 +449,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_OPERATION = APIOperation( input=EndpointWithHostLabelOperationInput, output=EndpointWithHostLabelOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -482,7 +474,7 @@ class FlattenedXmlMapInput: """Dataclass for FlattenedXmlMapInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FLATTENED_XML_MAP_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -494,13 +486,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FLATTENED_XML_MAP_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -516,7 +509,7 @@ def _serialize_foo_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -525,7 +518,7 @@ def _deserialize_foo_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -555,15 +548,12 @@ class FlattenedXmlMapOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FLATTENED_XML_MAP_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FLATTENED_XML_MAP_OUTPUT).members_by_index if self.my_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_OUTPUT.members["myMap"], - self.my_map, - ) + _serialize_foo_enum_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -572,30 +562,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["my_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_FLATTENED_XML_MAP_OUTPUT.members["myMap"] - ) + kwargs["my_map"] = _deserialize_foo_enum_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FLATTENED_XML_MAP_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLATTENED_XML_MAP = APIOperation( input=FlattenedXmlMapInput, output=FlattenedXmlMapOutput, - schema=_SCHEMA_FLATTENED_XML_MAP, - input_schema=_SCHEMA_FLATTENED_XML_MAP_INPUT, - output_schema=_SCHEMA_FLATTENED_XML_MAP_OUTPUT, + static_schema=_SCHEMA_FLATTENED_XML_MAP, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -604,7 +591,9 @@ class FlattenedXmlMapWithXmlNameInput: """Dataclass for FlattenedXmlMapWithXmlNameInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -616,15 +605,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -632,7 +620,7 @@ def _serialize_flattened_xml_map_with_xml_name_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -641,7 +629,7 @@ def _deserialize_flattened_xml_map_with_xml_name_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -671,14 +659,17 @@ class FlattenedXmlMapWithXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT + ).members_by_index if self.my_map is not None: _serialize_flattened_xml_map_with_xml_name_output_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -688,37 +679,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_flattened_xml_map_with_xml_name_output_map( - de, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT.members[ - "myMap" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLATTENED_XML_MAP_WITH_XML_NAME = APIOperation( input=FlattenedXmlMapWithXmlNameInput, output=FlattenedXmlMapWithXmlNameOutput, - schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME, - input_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, - output_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, + static_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -728,7 +713,7 @@ class FlattenedXmlMapWithXmlNamespaceInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, self + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -741,15 +726,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -757,7 +741,7 @@ def _serialize_flattened_xml_map_with_xml_namespace_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -766,7 +750,7 @@ def _deserialize_flattened_xml_map_with_xml_namespace_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -797,15 +781,16 @@ class FlattenedXmlMapWithXmlNamespaceOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, self + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT + ).members_by_index if self.my_map is not None: _serialize_flattened_xml_map_with_xml_namespace_output_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -815,37 +800,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_flattened_xml_map_with_xml_namespace_output_map( - de, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT.members[ - "myMap" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLATTENED_XML_MAP_WITH_XML_NAMESPACE = APIOperation( input=FlattenedXmlMapWithXmlNamespaceInput, output=FlattenedXmlMapWithXmlNamespaceOutput, - schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE, - input_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, - output_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, + static_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -854,7 +833,7 @@ class FractionalSecondsInput: """Dataclass for FractionalSecondsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -866,13 +845,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -893,13 +873,12 @@ class FractionalSecondsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -908,30 +887,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FRACTIONAL_SECONDS = APIOperation( input=FractionalSecondsInput, output=FractionalSecondsOutput, - schema=_SCHEMA_FRACTIONAL_SECONDS, - input_schema=_SCHEMA_FRACTIONAL_SECONDS_INPUT, - output_schema=_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, + static_schema=_SCHEMA_FRACTIONAL_SECONDS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -942,13 +918,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -957,18 +932,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -983,18 +958,15 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[0], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1003,21 +975,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[0]) case 1: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1028,13 +1000,12 @@ class CustomCodeError(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CUSTOM_CODE_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_CUSTOM_CODE_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CUSTOM_CODE_ERROR).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_CUSTOM_CODE_ERROR.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1043,18 +1014,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CUSTOM_CODE_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_CUSTOM_CODE_ERROR.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CUSTOM_CODE_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1063,7 +1034,7 @@ class GreetingWithErrorsInput: """Dataclass for GreetingWithErrorsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1075,13 +1046,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1102,13 +1074,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1117,20 +1088,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1141,13 +1110,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1156,27 +1124,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.query#InvalidGreeting"): InvalidGreeting, @@ -1185,11 +1151,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[ - _SCHEMA_INVALID_GREETING, - _SCHEMA_COMPLEX_ERROR, - _SCHEMA_CUSTOM_CODE_ERROR, - ], ) @@ -1198,7 +1159,7 @@ class HostWithPathOperationInput: """Dataclass for HostWithPathOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1210,15 +1171,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1237,7 +1197,7 @@ class HostWithPathOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1249,27 +1209,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HOST_WITH_PATH_OPERATION = APIOperation( input=HostWithPathOperationInput, output=HostWithPathOperationOutput, - schema=_SCHEMA_HOST_WITH_PATH_OPERATION, - input_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, - output_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, + static_schema=_SCHEMA_HOST_WITH_PATH_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1278,7 +1234,7 @@ class IgnoresWrappingXmlNameInput: """Dataclass for IgnoresWrappingXmlNameInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1290,15 +1246,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1319,13 +1274,12 @@ class IgnoresWrappingXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1334,32 +1288,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs IGNORES_WRAPPING_XML_NAME = APIOperation( input=IgnoresWrappingXmlNameInput, output=IgnoresWrappingXmlNameOutput, - schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME, - input_schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT, - output_schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT, + static_schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1378,7 +1327,7 @@ class NestedStructuresOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCTURES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCTURES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1390,13 +1339,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCTURES_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCTURES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1405,7 +1355,7 @@ class NoInputAndNoOutputInput: """Dataclass for NoInputAndNoOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1417,15 +1367,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1444,7 +1393,7 @@ class NoInputAndNoOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1456,27 +1405,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_NO_OUTPUT = APIOperation( input=NoInputAndNoOutputInput, output=NoInputAndNoOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1485,7 +1430,7 @@ class NoInputAndOutputInput: """Dataclass for NoInputAndOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1497,13 +1442,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1522,7 +1468,7 @@ class NoInputAndOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1534,25 +1480,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_OUTPUT = APIOperation( input=NoInputAndOutputInput, output=NoInputAndOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1565,19 +1509,15 @@ class PutWithContentEncodingInput: data: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT).members_by_index if self.encoding is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"], - self.encoding, - ) + serializer.write_string(members[0], self.encoding) if self.data is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"], self.data - ) + serializer.write_string(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1586,25 +1526,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["encoding"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"] - ) + kwargs["encoding"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"] - ) + kwargs["data"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1623,7 +1559,7 @@ class PutWithContentEncodingOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1635,27 +1571,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_WITH_CONTENT_ENCODING = APIOperation( input=PutWithContentEncodingInput, output=PutWithContentEncodingOutput, - schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, - input_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, - output_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, + static_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1666,14 +1598,16 @@ class QueryIdempotencyTokenAutoFillInput: token: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT + ).members_by_index if self.token is not None: - serializer.write_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"], - self.token, - ) + serializer.write_string(members[0], self.token) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1682,20 +1616,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["token"] = de.read_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"] - ) + kwargs["token"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1714,7 +1646,9 @@ class QueryIdempotencyTokenAutoFillOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1726,27 +1660,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = APIOperation( input=QueryIdempotencyTokenAutoFillInput, output=QueryIdempotencyTokenAutoFillOutput, - schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, - input_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, - output_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + static_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1757,11 +1687,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1770,23 +1701,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_greeting_list( serializer: ShapeSerializer, schema: Schema, value: list[GreetingStruct] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1811,7 +1744,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1821,7 +1754,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1837,7 +1770,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_xml_name( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1847,7 +1780,7 @@ def _deserialize_list_with_xml_name( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1867,15 +1800,12 @@ class NestedStructWithList: list_arg: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCT_WITH_LIST, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCT_WITH_LIST), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_STRUCT_WITH_LIST).members_by_index if self.list_arg is not None: - _serialize_string_list( - serializer, - _SCHEMA_NESTED_STRUCT_WITH_LIST.members["ListArg"], - self.list_arg, - ) + _serialize_string_list(serializer, members[0], self.list_arg) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1884,18 +1814,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCT_WITH_LIST) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["list_arg"] = _deserialize_string_list( - de, _SCHEMA_NESTED_STRUCT_WITH_LIST.members["ListArg"] - ) + kwargs["list_arg"] = _deserialize_string_list(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCT_WITH_LIST, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1916,47 +1846,31 @@ class QueryListsInput: nested_with_list: NestedStructWithList | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_LISTS_INPUT).members_by_index if self.list_arg is not None: - _serialize_string_list( - serializer, _SCHEMA_QUERY_LISTS_INPUT.members["ListArg"], self.list_arg - ) + _serialize_string_list(serializer, members[0], self.list_arg) if self.complex_list_arg is not None: - _serialize_greeting_list( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["ComplexListArg"], - self.complex_list_arg, - ) + _serialize_greeting_list(serializer, members[1], self.complex_list_arg) if self.flattened_list_arg is not None: - _serialize_string_list( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["FlattenedListArg"], - self.flattened_list_arg, - ) + _serialize_string_list(serializer, members[2], self.flattened_list_arg) if self.list_arg_with_xml_name_member is not None: _serialize_list_with_xml_name( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["ListArgWithXmlNameMember"], - self.list_arg_with_xml_name_member, + serializer, members[3], self.list_arg_with_xml_name_member ) if self.flattened_list_arg_with_xml_name is not None: _serialize_list_with_xml_name( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["FlattenedListArgWithXmlName"], - self.flattened_list_arg_with_xml_name, + serializer, members[4], self.flattened_list_arg_with_xml_name ) if self.nested_with_list is not None: - serializer.write_struct( - _SCHEMA_QUERY_LISTS_INPUT.members["NestedWithList"], - self.nested_with_list, - ) + serializer.write_struct(members[5], self.nested_with_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1965,51 +1879,41 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["list_arg"] = _deserialize_string_list( - de, _SCHEMA_QUERY_LISTS_INPUT.members["ListArg"] - ) + kwargs["list_arg"] = _deserialize_string_list(de, members[0]) case 1: kwargs["complex_list_arg"] = _deserialize_greeting_list( - de, _SCHEMA_QUERY_LISTS_INPUT.members["ComplexListArg"] + de, members[1] ) case 2: kwargs["flattened_list_arg"] = _deserialize_string_list( - de, _SCHEMA_QUERY_LISTS_INPUT.members["FlattenedListArg"] + de, members[2] ) case 3: kwargs["list_arg_with_xml_name_member"] = ( - _deserialize_list_with_xml_name( - de, - _SCHEMA_QUERY_LISTS_INPUT.members[ - "ListArgWithXmlNameMember" - ], - ) + _deserialize_list_with_xml_name(de, members[3]) ) case 4: kwargs["flattened_list_arg_with_xml_name"] = ( - _deserialize_list_with_xml_name( - de, - _SCHEMA_QUERY_LISTS_INPUT.members[ - "FlattenedListArgWithXmlName" - ], - ) + _deserialize_list_with_xml_name(de, members[4]) ) case 5: kwargs["nested_with_list"] = NestedStructWithList.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2028,7 +1932,7 @@ class QueryListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2040,25 +1944,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_LISTS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_LISTS = APIOperation( input=QueryListsInput, output=QueryListsOutput, - schema=_SCHEMA_QUERY_LISTS, - input_schema=_SCHEMA_QUERY_LISTS_INPUT, - output_schema=_SCHEMA_QUERY_LISTS_OUTPUT, + static_schema=_SCHEMA_QUERY_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2066,7 +1968,7 @@ def _serialize_complex_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -2075,7 +1977,7 @@ def _deserialize_complex_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2092,7 +1994,7 @@ def _serialize_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2101,7 +2003,7 @@ def _deserialize_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2118,7 +2020,7 @@ def _serialize_map_with_xml_name( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2127,7 +2029,7 @@ def _deserialize_map_with_xml_name( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2144,7 +2046,7 @@ def _serialize_map_of_lists( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_string_list(vs, value_schema, v)) @@ -2153,7 +2055,7 @@ def _deserialize_map_of_lists( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str]]: result: dict[str, list[str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2173,15 +2075,12 @@ class NestedStructWithMap: map_arg: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCT_WITH_MAP, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCT_WITH_MAP), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_STRUCT_WITH_MAP).members_by_index if self.map_arg is not None: - _serialize_string_map( - serializer, - _SCHEMA_NESTED_STRUCT_WITH_MAP.members["MapArg"], - self.map_arg, - ) + _serialize_string_map(serializer, members[0], self.map_arg) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2190,18 +2089,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCT_WITH_MAP) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["map_arg"] = _deserialize_string_map( - de, _SCHEMA_NESTED_STRUCT_WITH_MAP.members["MapArg"] - ) + kwargs["map_arg"] = _deserialize_string_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCT_WITH_MAP, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2226,61 +2125,37 @@ class QueryMapsInput: nested_struct_with_map: NestedStructWithMap | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_MAPS_INPUT).members_by_index if self.map_arg is not None: - _serialize_string_map( - serializer, _SCHEMA_QUERY_MAPS_INPUT.members["MapArg"], self.map_arg - ) + _serialize_string_map(serializer, members[0], self.map_arg) if self.renamed_map_arg is not None: - _serialize_string_map( - serializer, - _SCHEMA_QUERY_MAPS_INPUT.members["RenamedMapArg"], - self.renamed_map_arg, - ) + _serialize_string_map(serializer, members[1], self.renamed_map_arg) if self.complex_map_arg is not None: - _serialize_complex_map( - serializer, - _SCHEMA_QUERY_MAPS_INPUT.members["ComplexMapArg"], - self.complex_map_arg, - ) + _serialize_complex_map(serializer, members[2], self.complex_map_arg) if self.map_with_xml_member_name is not None: _serialize_map_with_xml_name( - serializer, - _SCHEMA_QUERY_MAPS_INPUT.members["MapWithXmlMemberName"], - self.map_with_xml_member_name, + serializer, members[3], self.map_with_xml_member_name ) if self.flattened_map is not None: - _serialize_string_map( - serializer, - _SCHEMA_QUERY_MAPS_INPUT.members["FlattenedMap"], - self.flattened_map, - ) + _serialize_string_map(serializer, members[4], self.flattened_map) if self.flattened_map_with_xml_name is not None: _serialize_map_with_xml_name( - serializer, - _SCHEMA_QUERY_MAPS_INPUT.members["FlattenedMapWithXmlName"], - self.flattened_map_with_xml_name, + serializer, members[5], self.flattened_map_with_xml_name ) if self.map_of_lists is not None: - _serialize_map_of_lists( - serializer, - _SCHEMA_QUERY_MAPS_INPUT.members["MapOfLists"], - self.map_of_lists, - ) + _serialize_map_of_lists(serializer, members[6], self.map_of_lists) if self.nested_struct_with_map is not None: - serializer.write_struct( - _SCHEMA_QUERY_MAPS_INPUT.members["NestedStructWithMap"], - self.nested_struct_with_map, - ) + serializer.write_struct(members[7], self.nested_struct_with_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2289,46 +2164,35 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["map_arg"] = _deserialize_string_map( - de, _SCHEMA_QUERY_MAPS_INPUT.members["MapArg"] - ) + kwargs["map_arg"] = _deserialize_string_map(de, members[0]) case 1: - kwargs["renamed_map_arg"] = _deserialize_string_map( - de, _SCHEMA_QUERY_MAPS_INPUT.members["RenamedMapArg"] - ) + kwargs["renamed_map_arg"] = _deserialize_string_map(de, members[1]) case 2: - kwargs["complex_map_arg"] = _deserialize_complex_map( - de, _SCHEMA_QUERY_MAPS_INPUT.members["ComplexMapArg"] - ) + kwargs["complex_map_arg"] = _deserialize_complex_map(de, members[2]) case 3: kwargs["map_with_xml_member_name"] = _deserialize_map_with_xml_name( - de, _SCHEMA_QUERY_MAPS_INPUT.members["MapWithXmlMemberName"] + de, members[3] ) case 4: - kwargs["flattened_map"] = _deserialize_string_map( - de, _SCHEMA_QUERY_MAPS_INPUT.members["FlattenedMap"] - ) + kwargs["flattened_map"] = _deserialize_string_map(de, members[4]) case 5: kwargs["flattened_map_with_xml_name"] = ( - _deserialize_map_with_xml_name( - de, - _SCHEMA_QUERY_MAPS_INPUT.members["FlattenedMapWithXmlName"], - ) + _deserialize_map_with_xml_name(de, members[5]) ) case 6: - kwargs["map_of_lists"] = _deserialize_map_of_lists( - de, _SCHEMA_QUERY_MAPS_INPUT.members["MapOfLists"] - ) + kwargs["map_of_lists"] = _deserialize_map_of_lists(de, members[6]) case 7: kwargs["nested_struct_with_map"] = NestedStructWithMap.deserialize( @@ -2336,9 +2200,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2357,7 +2221,7 @@ class QueryMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2369,25 +2233,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_MAPS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_MAPS = APIOperation( input=QueryMapsInput, output=QueryMapsOutput, - schema=_SCHEMA_QUERY_MAPS, - input_schema=_SCHEMA_QUERY_MAPS_INPUT, - output_schema=_SCHEMA_QUERY_MAPS_OUTPUT, + static_schema=_SCHEMA_QUERY_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2402,24 +2264,18 @@ class QueryTimestampsInput: epoch_target: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_TIMESTAMPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_TIMESTAMPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_TIMESTAMPS_INPUT).members_by_index if self.normal_format is not None: - serializer.write_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["normalFormat"], - self.normal_format, - ) + serializer.write_timestamp(members[0], self.normal_format) if self.epoch_member is not None: - serializer.write_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochMember"], self.epoch_member - ) + serializer.write_timestamp(members[1], self.epoch_member) if self.epoch_target is not None: - serializer.write_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochTarget"], self.epoch_target - ) + serializer.write_timestamp(members[2], self.epoch_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2428,28 +2284,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_TIMESTAMPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal_format"] = de.read_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["normalFormat"] - ) + kwargs["normal_format"] = de.read_timestamp(members[0]) case 1: - kwargs["epoch_member"] = de.read_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochMember"] - ) + kwargs["epoch_member"] = de.read_timestamp(members[1]) case 2: - kwargs["epoch_target"] = de.read_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochTarget"] - ) + kwargs["epoch_target"] = de.read_timestamp(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_TIMESTAMPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2468,7 +2320,7 @@ class QueryTimestampsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2480,25 +2332,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_TIMESTAMPS = APIOperation( input=QueryTimestampsInput, output=QueryTimestampsOutput, - schema=_SCHEMA_QUERY_TIMESTAMPS, - input_schema=_SCHEMA_QUERY_TIMESTAMPS_INPUT, - output_schema=_SCHEMA_QUERY_TIMESTAMPS_OUTPUT, + static_schema=_SCHEMA_QUERY_TIMESTAMPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2507,7 +2357,7 @@ class RecursiveXmlShapesInput: """Dataclass for RecursiveXmlShapesInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2519,13 +2369,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2558,55 +2409,36 @@ class SimpleInputParamsInput: integer_enum: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.bar is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bar"], self.bar - ) + serializer.write_string(members[1], self.bar) if self.baz is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Baz"], self.baz - ) + serializer.write_boolean(members[2], self.baz) if self.bam is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bam"], self.bam - ) + serializer.write_integer(members[3], self.bam) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FloatValue"], - self.float_value, - ) + serializer.write_float(members[4], self.float_value) if self.boo is not None: - serializer.write_double( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Boo"], self.boo - ) + serializer.write_double(members[5], self.boo) if self.qux is not None: - serializer.write_blob( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Qux"], self.qux - ) + serializer.write_blob(members[6], self.qux) if self.foo_enum is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FooEnum"], self.foo_enum - ) + serializer.write_string(members[7], self.foo_enum) if self.integer_enum is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["IntegerEnum"], - self.integer_enum, - ) + serializer.write_integer(members[8], self.integer_enum) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2615,62 +2447,42 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["bar"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bar"] - ) + kwargs["bar"] = de.read_string(members[1]) case 2: - kwargs["baz"] = de.read_boolean( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Baz"] - ) + kwargs["baz"] = de.read_boolean(members[2]) case 3: - kwargs["bam"] = de.read_integer( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bam"] - ) + kwargs["bam"] = de.read_integer(members[3]) case 4: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FloatValue"] - ) + kwargs["float_value"] = de.read_float(members[4]) case 5: - kwargs["boo"] = de.read_double( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Boo"] - ) + kwargs["boo"] = de.read_double(members[5]) case 6: - kwargs["qux"] = de.read_blob( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Qux"] - ) + kwargs["qux"] = de.read_blob(members[6]) case 7: - kwargs["foo_enum"] = FooEnum( - de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FooEnum"] - ) - ) + kwargs["foo_enum"] = FooEnum(de.read_string(members[7])) case 8: - kwargs["integer_enum"] = IntegerEnum( - de.read_integer( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["IntegerEnum"] - ) - ) + kwargs["integer_enum"] = IntegerEnum(de.read_integer(members[8])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2689,7 +2501,7 @@ class SimpleInputParamsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2701,25 +2513,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_INPUT_PARAMS = APIOperation( input=SimpleInputParamsInput, output=SimpleInputParamsOutput, - schema=_SCHEMA_SIMPLE_INPUT_PARAMS, - input_schema=_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT, - output_schema=_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT, + static_schema=_SCHEMA_SIMPLE_INPUT_PARAMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2728,7 +2538,9 @@ class SimpleScalarXmlPropertiesInput: """Dataclass for SimpleScalarXmlPropertiesInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2740,15 +2552,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2787,70 +2598,41 @@ class SimpleScalarXmlPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT).members_by_index if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[0], self.string_value) if self.empty_string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["emptyStringValue"], - self.empty_string_value, - ) + serializer.write_string(members[1], self.empty_string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[9], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2859,93 +2641,54 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "stringValue" - ] - ) + kwargs["string_value"] = de.read_string(members[0]) case 1: - kwargs["empty_string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "emptyStringValue" - ] - ) + kwargs["empty_string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "shortValue" - ] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "integerValue" - ] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "floatValue" - ] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "doubleValue" - ] - ) + kwargs["double_value"] = de.read_double(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_XML_PROPERTIES = APIOperation( input=SimpleScalarXmlPropertiesInput, output=SimpleScalarXmlPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2954,7 +2697,7 @@ class XmlBlobsInput: """Dataclass for XmlBlobsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2966,13 +2709,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_BLOBS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2993,13 +2737,12 @@ class XmlBlobsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob( - _SCHEMA_XML_BLOBS_OPERATION_OUTPUT.members["data"], self.data - ) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3008,30 +2751,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_BLOBS_OPERATION_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_BLOBS = APIOperation( input=XmlBlobsInput, output=XmlBlobsOperationOutput, - schema=_SCHEMA_XML_BLOBS, - input_schema=_SCHEMA_XML_BLOBS_INPUT, - output_schema=_SCHEMA_XML_BLOBS_OPERATION_OUTPUT, + static_schema=_SCHEMA_XML_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3040,7 +2780,7 @@ class XmlEmptyBlobsInput: """Dataclass for XmlEmptyBlobsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3052,13 +2792,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3079,13 +2820,12 @@ class XmlEmptyBlobsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob( - _SCHEMA_XML_EMPTY_BLOBS_OUTPUT.members["data"], self.data - ) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3094,30 +2834,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_EMPTY_BLOBS_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_BLOBS = APIOperation( input=XmlEmptyBlobsInput, output=XmlEmptyBlobsOutput, - schema=_SCHEMA_XML_EMPTY_BLOBS, - input_schema=_SCHEMA_XML_EMPTY_BLOBS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3126,7 +2863,7 @@ class XmlEmptyListsInput: """Dataclass for XmlEmptyListsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3138,20 +2875,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_boolean_list( serializer: ShapeSerializer, schema: Schema, value: list[bool] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_boolean(member_schema, e) @@ -3161,7 +2899,7 @@ def _deserialize_boolean_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[bool]: result: list[bool] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3177,7 +2915,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_foo_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3187,7 +2925,7 @@ def _deserialize_foo_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3203,7 +2941,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_renamed_list_members( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3213,7 +2951,7 @@ def _deserialize_renamed_list_members( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3229,7 +2967,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_member_namespace( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3239,7 +2977,7 @@ def _deserialize_list_with_member_namespace( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3255,7 +2993,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_namespace( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3265,7 +3003,7 @@ def _deserialize_list_with_namespace( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3281,7 +3019,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -3291,7 +3029,7 @@ def _deserialize_integer_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3307,7 +3045,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -3317,7 +3055,7 @@ def _deserialize_integer_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3333,7 +3071,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_nested_string_list( serializer: ShapeSerializer, schema: Schema, value: list[list[str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_string_list(ls, member_schema, e) @@ -3343,7 +3081,7 @@ def _deserialize_nested_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[list[str]]: result: list[list[str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3359,7 +3097,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3369,7 +3107,7 @@ def _deserialize_string_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3391,14 +3129,15 @@ class StructureListMember: b: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER).members_by_index if self.a is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["a"], self.a) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["b"], self.b) + serializer.write_string(members[1], self.b) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3407,30 +3146,28 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_structure_list( serializer: ShapeSerializer, schema: Schema, value: list[StructureListMember] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -3455,7 +3192,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_timestamp_list( serializer: ShapeSerializer, schema: Schema, value: list[datetime] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_timestamp(member_schema, e) @@ -3465,7 +3202,7 @@ def _deserialize_timestamp_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[datetime]: result: list[datetime] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3522,108 +3259,61 @@ class XmlEmptyListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedListWithNamespace"], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3632,105 +3322,84 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["renamedListMembers"] + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["structureList"] + de, members[13] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_LISTS = APIOperation( input=XmlEmptyListsInput, output=XmlEmptyListsOutput, - schema=_SCHEMA_XML_EMPTY_LISTS, - input_schema=_SCHEMA_XML_EMPTY_LISTS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_LISTS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3739,7 +3408,7 @@ class XmlEmptyMapsInput: """Dataclass for XmlEmptyMapsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3751,13 +3420,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_MAPS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3765,7 +3435,7 @@ def _serialize_xml_maps_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -3774,7 +3444,7 @@ def _deserialize_xml_maps_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -3804,13 +3474,12 @@ class XmlEmptyMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_MAPS_OUTPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_output_map( - serializer, _SCHEMA_XML_EMPTY_MAPS_OUTPUT.members["myMap"], self.my_map - ) + _serialize_xml_maps_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3819,30 +3488,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["my_map"] = _deserialize_xml_maps_output_map( - de, _SCHEMA_XML_EMPTY_MAPS_OUTPUT.members["myMap"] - ) + kwargs["my_map"] = _deserialize_xml_maps_output_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_MAPS = APIOperation( input=XmlEmptyMapsInput, output=XmlEmptyMapsOutput, - schema=_SCHEMA_XML_EMPTY_MAPS, - input_schema=_SCHEMA_XML_EMPTY_MAPS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_MAPS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3851,7 +3517,7 @@ class XmlEnumsInput: """Dataclass for XmlEnumsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3863,20 +3529,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ENUMS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_foo_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3886,7 +3553,7 @@ def _deserialize_foo_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3926,44 +3593,27 @@ class XmlEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ENUMS_OUTPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3972,55 +3622,42 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_ENUMS = APIOperation( input=XmlEnumsInput, output=XmlEnumsOutput, - schema=_SCHEMA_XML_ENUMS, - input_schema=_SCHEMA_XML_ENUMS_INPUT, - output_schema=_SCHEMA_XML_ENUMS_OUTPUT, + static_schema=_SCHEMA_XML_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4029,7 +3666,7 @@ class XmlIntEnumsInput: """Dataclass for XmlIntEnumsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_INT_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_INT_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4041,13 +3678,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_INT_ENUMS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_INT_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4055,7 +3693,7 @@ def _serialize_integer_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -4064,7 +3702,7 @@ def _deserialize_integer_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -4080,7 +3718,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_integer_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -4090,7 +3728,7 @@ def _deserialize_integer_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -4130,44 +3768,27 @@ class XmlIntEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_INT_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT).members_by_index if self.int_enum1 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum1"], self.int_enum1 - ) + serializer.write_integer(members[0], self.int_enum1) if self.int_enum2 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum2"], self.int_enum2 - ) + serializer.write_integer(members[1], self.int_enum2) if self.int_enum3 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum3"], self.int_enum3 - ) + serializer.write_integer(members[2], self.int_enum3) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.int_enum_list) if self.int_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumSet"], - self.int_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.int_enum_set) if self.int_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumMap"], - self.int_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.int_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4176,61 +3797,48 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum1"] - ) - ) + kwargs["int_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["int_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum2"] - ) - ) + kwargs["int_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["int_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum3"] - ) - ) + kwargs["int_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumList"] + de, members[3] ) case 4: kwargs["int_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumSet"] + de, members[4] ) case 5: kwargs["int_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_INT_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_INT_ENUMS = APIOperation( input=XmlIntEnumsInput, output=XmlIntEnumsOutput, - schema=_SCHEMA_XML_INT_ENUMS, - input_schema=_SCHEMA_XML_INT_ENUMS_INPUT, - output_schema=_SCHEMA_XML_INT_ENUMS_OUTPUT, + static_schema=_SCHEMA_XML_INT_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4239,7 +3847,7 @@ class XmlListsInput: """Dataclass for XmlListsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4251,13 +3859,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_LISTS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4305,110 +3914,61 @@ class XmlListsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_LISTS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_LISTS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_LISTS_OPERATION_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithNamespace" - ], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4417,109 +3977,84 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_LISTS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["nestedStringList"], + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "renamedListMembers" - ], + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["structureList"] + de, members[13] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_LISTS_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_LISTS = APIOperation( input=XmlListsInput, output=XmlListsOperationOutput, - schema=_SCHEMA_XML_LISTS, - input_schema=_SCHEMA_XML_LISTS_INPUT, - output_schema=_SCHEMA_XML_LISTS_OPERATION_OUTPUT, + static_schema=_SCHEMA_XML_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4528,7 +4063,7 @@ class XmlMapsInput: """Dataclass for XmlMapsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4540,13 +4075,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4567,15 +4103,12 @@ class XmlMapsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAPS_OPERATION_OUTPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_output_map( - serializer, - _SCHEMA_XML_MAPS_OPERATION_OUTPUT.members["myMap"], - self.my_map, - ) + _serialize_xml_maps_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4584,30 +4117,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["my_map"] = _deserialize_xml_maps_output_map( - de, _SCHEMA_XML_MAPS_OPERATION_OUTPUT.members["myMap"] - ) + kwargs["my_map"] = _deserialize_xml_maps_output_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_MAPS = APIOperation( input=XmlMapsInput, output=XmlMapsOperationOutput, - schema=_SCHEMA_XML_MAPS, - input_schema=_SCHEMA_XML_MAPS_INPUT, - output_schema=_SCHEMA_XML_MAPS_OPERATION_OUTPUT, + static_schema=_SCHEMA_XML_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4616,7 +4146,7 @@ class XmlMapsXmlNameInput: """Dataclass for XmlMapsXmlNameInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_XML_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_XML_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4628,13 +4158,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_XML_NAME_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_XML_NAME_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4642,7 +4173,7 @@ def _serialize_xml_maps_xml_name_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -4651,7 +4182,7 @@ def _deserialize_xml_maps_xml_name_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -4681,15 +4212,12 @@ class XmlMapsXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_xml_name_output_map( - serializer, - _SCHEMA_XML_MAPS_XML_NAME_OUTPUT.members["myMap"], - self.my_map, - ) + _serialize_xml_maps_xml_name_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4698,30 +4226,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_xml_name_output_map( - de, _SCHEMA_XML_MAPS_XML_NAME_OUTPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_MAPS_XML_NAME = APIOperation( input=XmlMapsXmlNameInput, output=XmlMapsXmlNameOutput, - schema=_SCHEMA_XML_MAPS_XML_NAME, - input_schema=_SCHEMA_XML_MAPS_XML_NAME_INPUT, - output_schema=_SCHEMA_XML_MAPS_XML_NAME_OUTPUT, + static_schema=_SCHEMA_XML_MAPS_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4730,7 +4257,7 @@ class XmlNamespacesInput: """Dataclass for XmlNamespacesInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4742,20 +4269,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACES_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_xml_namespaced_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -4765,7 +4293,7 @@ def _deserialize_xml_namespaced_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -4787,18 +4315,15 @@ class XmlNamespaceNested: values: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACE_NESTED, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACE_NESTED), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACE_NESTED).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_NAMESPACE_NESTED.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.values is not None: - _serialize_xml_namespaced_list( - serializer, _SCHEMA_XML_NAMESPACE_NESTED.members["values"], self.values - ) + _serialize_xml_namespaced_list(serializer, members[1], self.values) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4807,23 +4332,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACE_NESTED) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_NAMESPACE_NESTED.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["values"] = _deserialize_xml_namespaced_list( - de, _SCHEMA_XML_NAMESPACE_NESTED.members["values"] - ) + kwargs["values"] = _deserialize_xml_namespaced_list(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACE_NESTED, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4844,13 +4367,12 @@ class XmlNamespacesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_XML_NAMESPACES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4859,28 +4381,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = XmlNamespaceNested.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_NAMESPACES = APIOperation( input=XmlNamespacesInput, output=XmlNamespacesOutput, - schema=_SCHEMA_XML_NAMESPACES, - input_schema=_SCHEMA_XML_NAMESPACES_INPUT, - output_schema=_SCHEMA_XML_NAMESPACES_OUTPUT, + static_schema=_SCHEMA_XML_NAMESPACES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4889,7 +4410,7 @@ class XmlTimestampsInput: """Dataclass for XmlTimestampsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_TIMESTAMPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4901,13 +4422,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_TIMESTAMPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4940,47 +4462,30 @@ class XmlTimestampsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_TIMESTAMPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT).members_by_index if self.normal is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["normal"], self.normal - ) + serializer.write_timestamp(members[0], self.normal) if self.date_time is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTime"], self.date_time - ) + serializer.write_timestamp(members[1], self.date_time) if self.date_time_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"], - self.date_time_on_target, - ) + serializer.write_timestamp(members[2], self.date_time_on_target) if self.epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSeconds"], - self.epoch_seconds, - ) + serializer.write_timestamp(members[3], self.epoch_seconds) if self.epoch_seconds_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"], - self.epoch_seconds_on_target, - ) + serializer.write_timestamp(members[4], self.epoch_seconds_on_target) if self.http_date is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDate"], self.http_date - ) + serializer.write_timestamp(members[5], self.http_date) if self.http_date_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"], - self.http_date_on_target, - ) + serializer.write_timestamp(members[6], self.http_date_on_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4989,60 +4494,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["normal"] - ) + kwargs["normal"] = de.read_timestamp(members[0]) case 1: - kwargs["date_time"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTime"] - ) + kwargs["date_time"] = de.read_timestamp(members[1]) case 2: - kwargs["date_time_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"] - ) + kwargs["date_time_on_target"] = de.read_timestamp(members[2]) case 3: - kwargs["epoch_seconds"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSeconds"] - ) + kwargs["epoch_seconds"] = de.read_timestamp(members[3]) case 4: - kwargs["epoch_seconds_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"] - ) + kwargs["epoch_seconds_on_target"] = de.read_timestamp(members[4]) case 5: - kwargs["http_date"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDate"] - ) + kwargs["http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["http_date_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"] - ) + kwargs["http_date_on_target"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_TIMESTAMPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_TIMESTAMPS = APIOperation( input=XmlTimestampsInput, output=XmlTimestampsOutput, - schema=_SCHEMA_XML_TIMESTAMPS, - input_schema=_SCHEMA_XML_TIMESTAMPS_INPUT, - output_schema=_SCHEMA_XML_TIMESTAMPS_OUTPUT, + static_schema=_SCHEMA_XML_TIMESTAMPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5057,23 +4547,18 @@ class StructArg: recursive_arg: "StructArg | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCT_ARG, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCT_ARG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCT_ARG).members_by_index if self.string_arg is not None: - serializer.write_string( - _SCHEMA_STRUCT_ARG.members["StringArg"], self.string_arg - ) + serializer.write_string(members[0], self.string_arg) if self.other_arg is not None: - serializer.write_boolean( - _SCHEMA_STRUCT_ARG.members["OtherArg"], self.other_arg - ) + serializer.write_boolean(members[1], self.other_arg) if self.recursive_arg is not None: - serializer.write_struct( - _SCHEMA_STRUCT_ARG.members["RecursiveArg"], self.recursive_arg - ) + serializer.write_struct(members[2], self.recursive_arg) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5082,26 +4567,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCT_ARG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_arg"] = de.read_string( - _SCHEMA_STRUCT_ARG.members["StringArg"] - ) + kwargs["string_arg"] = de.read_string(members[0]) case 1: - kwargs["other_arg"] = de.read_boolean( - _SCHEMA_STRUCT_ARG.members["OtherArg"] - ) + kwargs["other_arg"] = de.read_boolean(members[1]) case 2: kwargs["recursive_arg"] = StructArg.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCT_ARG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5112,13 +4595,12 @@ class NestedStructuresInput: nested: "StructArg | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCTURES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCTURES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_STRUCTURES_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_NESTED_STRUCTURES_INPUT.members["Nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5127,16 +4609,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCTURES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = StructArg.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCTURES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5149,19 +4633,17 @@ class RecursiveXmlShapesOutputNested1: nested: "RecursiveXmlShapesOutputNested2 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["nested"], - self.nested, - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5170,23 +4652,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: kwargs["nested"] = RecursiveXmlShapesOutputNested2.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5199,19 +4679,17 @@ class RecursiveXmlShapesOutputNested2: recursive_member: "RecursiveXmlShapesOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2).members_by_index if self.bar is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2.members["bar"], self.bar - ) + serializer.write_string(members[0], self.bar) if self.recursive_member is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2.members["recursiveMember"], - self.recursive_member, - ) + serializer.write_struct(members[1], self.recursive_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5220,13 +4698,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bar"] = de.read_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2.members["bar"] - ) + kwargs["bar"] = de.read_string(members[0]) case 1: kwargs["recursive_member"] = ( @@ -5234,23 +4712,18 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NESTED_STRUCTURES = APIOperation( input=NestedStructuresInput, output=NestedStructuresOutput, - schema=_SCHEMA_NESTED_STRUCTURES, - input_schema=_SCHEMA_NESTED_STRUCTURES_INPUT, - output_schema=_SCHEMA_NESTED_STRUCTURES_OUTPUT, + static_schema=_SCHEMA_NESTED_STRUCTURES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5271,13 +4744,12 @@ class RecursiveXmlShapesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5286,28 +4758,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveXmlShapesOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RECURSIVE_XML_SHAPES = APIOperation( input=RecursiveXmlShapesInput, output=RecursiveXmlShapesOutput, - schema=_SCHEMA_RECURSIVE_XML_SHAPES, - input_schema=_SCHEMA_RECURSIVE_XML_SHAPES_INPUT, - output_schema=_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT, + static_schema=_SCHEMA_RECURSIVE_XML_SHAPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) diff --git a/codegen-output/ec2-query/pyproject.toml b/codegen-output/ec2-query/pyproject.toml index ed7ba732d..322d56bf8 100644 --- a/codegen-output/ec2-query/pyproject.toml +++ b/codegen-output/ec2-query/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/ec2-query/src/ec2query/_private/schemas.py b/codegen-output/ec2-query/src/ec2query/_private/schemas.py index ad8d60ab2..d7d45bfbe 100644 --- a/codegen-output/ec2-query/src/ec2query/_private/schemas.py +++ b/codegen-output/ec2-query/src/ec2query/_private/schemas.py @@ -2,1361 +2,1088 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - BYTE, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -DATETIME_OFFSETS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#DatetimeOffsetsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.shared#DateTime"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], -) - -DATETIME_OFFSETS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#DatetimeOffsetsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -DATETIME_OFFSETS = Schema( - id=ShapeID("aws.protocoltests.ec2#DatetimeOffsets"), shape_type=ShapeType.OPERATION -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#EmptyInputAndEmptyOutputInput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#EmptyInputAndEmptyOutputOutput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.ec2#EmptyInputAndEmptyOutput"), - shape_type=ShapeType.OPERATION, -) - -ENDPOINT_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#EndpointOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#EndpointOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION = Schema( - id=ShapeID("aws.protocoltests.ec2#EndpointOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo."}), - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#EndpointWithHostLabelOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.ec2#HostLabelInput", - ) - ], - members={ - "label": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#EndpointWithHostLabelOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_WITH_HOST_LABEL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.ec2#EndpointWithHostLabelOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo.{label}."}), - ) - ], -) - -FRACTIONAL_SECONDS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#FractionalSecondsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -FRACTIONAL_SECONDS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#FractionalSecondsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -FRACTIONAL_SECONDS = Schema( - id=ShapeID("aws.protocoltests.ec2#FractionalSeconds"), - shape_type=ShapeType.OPERATION, -) - -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#ComplexNestedErrorData"), - members={"Foo": {"target": STRING}}, -) - -COMPLEX_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#ComplexError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, -) - -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#GreetingWithErrorsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#GreetingWithErrorsOutput"), - members={"greeting": {"target": STRING}}, -) - -INVALID_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#InvalidGreeting"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={"Message": {"target": STRING}}, -) - -GREETING_WITH_ERRORS = Schema( - id=ShapeID("aws.protocoltests.ec2#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, -) - -HOST_WITH_PATH_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#HostWithPathOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HOST_WITH_PATH_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#HostWithPathOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HOST_WITH_PATH_OPERATION = Schema( - id=ShapeID("aws.protocoltests.ec2#HostWithPathOperation"), - shape_type=ShapeType.OPERATION, -) - -IGNORES_WRAPPING_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#IgnoresWrappingXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -IGNORES_WRAPPING_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#IgnoresWrappingXmlNameOutput"), - traits=[Trait.new(id=ShapeID("smithy.api#xmlName"), value="IgnoreMe")], - members={"foo": {"target": STRING}}, -) - -IGNORES_WRAPPING_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.ec2#IgnoresWrappingXmlName"), - shape_type=ShapeType.OPERATION, -) - -NESTED_STRUCTURES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#NestedStructuresOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#NoInputAndOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#NoInputAndOutputOutput") -) - -NO_INPUT_AND_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.ec2#NoInputAndOutput"), shape_type=ShapeType.OPERATION -) - -PUT_WITH_CONTENT_ENCODING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#PutWithContentEncodingInput"), - members={ - "encoding": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Encoding") - ], - }, - "data": {"target": STRING}, - }, -) - -PUT_WITH_CONTENT_ENCODING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#PutWithContentEncodingOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -PUT_WITH_CONTENT_ENCODING = Schema( - id=ShapeID("aws.protocoltests.ec2#PutWithContentEncoding"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#requestCompression"), - value=MappingProxyType({"encodings": ("gzip",)}), - ) - ], -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#QueryIdempotencyTokenAutoFillInput"), - members={ - "token": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#idempotencyToken"))], - } - }, -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#QueryIdempotencyTokenAutoFillOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = Schema( - id=ShapeID("aws.protocoltests.ec2#QueryIdempotencyTokenAutoFill"), - shape_type=ShapeType.OPERATION, -) - -GREETING_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, -) - -GREETING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingList"), - shape_type=ShapeType.LIST, - members={"member": {"target": GREETING_STRUCT}}, -) - -STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) -LIST_WITH_XML_NAME = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#ListWithXmlName"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, -) - -NESTED_STRUCT_WITH_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#NestedStructWithList"), - members={"ListArg": {"target": STRING_LIST}}, -) - -QUERY_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#QueryListsInput"), - members={ - "ListArg": {"target": STRING_LIST}, - "ComplexListArg": {"target": GREETING_LIST}, - "ListArgWithXmlNameMember": {"target": LIST_WITH_XML_NAME}, - "ListArgWithXmlName": { - "target": LIST_WITH_XML_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="Hi")], - }, - "NestedWithList": {"target": NESTED_STRUCT_WITH_LIST}, - }, +n0 = "aws.protocoltests.ec2" +_DOI = "DatetimeOffsetsInput" +_sSI = "smithy.synthetic#originalShapeId" +_sU = "smithy.api#Unit" +n1 = "aws.protocoltests.shared" +_DT = "DateTime" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_DOO = "DatetimeOffsetsOutput" +_d = "datetime" +_DO = "DatetimeOffsets" +_EIAEOI = "EmptyInputAndEmptyOutputInput" +_EIAEOO = "EmptyInputAndEmptyOutputOutput" +_EIAEO = "EmptyInputAndEmptyOutput" +_EOI = "EndpointOperationInput" +_EOO = "EndpointOperationOutput" +_EO = "EndpointOperation" +_s = "smithy.api#endpoint" +_EWHLOI = "EndpointWithHostLabelOperationInput" +_aHLI = "aws.protocoltests.ec2#HostLabelInput" +_l = "label" +_sL = "smithy.api#hostLabel" +_sm = "smithy.api#required" +_EWHLOO = "EndpointWithHostLabelOperationOutput" +_EWHLO = "EndpointWithHostLabelOperation" +_FSI = "FractionalSecondsInput" +_FSO = "FractionalSecondsOutput" +_FS = "FractionalSeconds" +_CNED = "ComplexNestedErrorData" +_F = "Foo" +_CE = "ComplexError" +_smi = "smithy.api#error" +_c = "client" +_TL = "TopLevel" +_N = "Nested" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_g = "greeting" +_IG = "InvalidGreeting" +_M = "Message" +_GWE = "GreetingWithErrors" +_HWPOI = "HostWithPathOperationInput" +_HWPOO = "HostWithPathOperationOutput" +_HWPO = "HostWithPathOperation" +_IWXNI = "IgnoresWrappingXmlNameInput" +_IWXNO = "IgnoresWrappingXmlNameOutput" +_sN = "smithy.api#xmlName" +_IM = "IgnoreMe" +_f = "foo" +_IWXN = "IgnoresWrappingXmlName" +_NSO = "NestedStructuresOutput" +_NIAOI = "NoInputAndOutputInput" +_NIAOO = "NoInputAndOutputOutput" +_NIAO = "NoInputAndOutput" +_PWCEI = "PutWithContentEncodingInput" +_e = "encoding" +_sH = "smithy.api#httpHeader" +_CE_ = "Content-Encoding" +_da = "data" +_PWCEO = "PutWithContentEncodingOutput" +_PWCE = "PutWithContentEncoding" +_sC = "smithy.api#requestCompression" +_QITAFI = "QueryIdempotencyTokenAutoFillInput" +_t = "token" +_sT = "smithy.api#idempotencyToken" +_QITAFO = "QueryIdempotencyTokenAutoFillOutput" +_QITAF = "QueryIdempotencyTokenAutoFill" +_GS = "GreetingStruct" +_h = "hi" +_GL = "GreetingList" +_m = "member" +_SL = "StringList" +_LWXN = "ListWithXmlName" +_i = "item" +_NSWL = "NestedStructWithList" +_LA = "ListArg" +_QLI = "QueryListsInput" +_CLA = "ComplexListArg" +_LAWXNM = "ListArgWithXmlNameMember" +_LAWXN = "ListArgWithXmlName" +_H = "Hi" +_NWL = "NestedWithList" +_QLO = "QueryListsOutput" +_QL = "QueryLists" +_ES = "EpochSeconds" +_es = "epoch-seconds" +_QTI = "QueryTimestampsInput" +_nF = "normalFormat" +_eM = "epochMember" +_eT = "epochTarget" +_QTO = "QueryTimestampsOutput" +_QT = "QueryTimestamps" +_RXSI = "RecursiveXmlShapesInput" +_FE = "FooEnum" +_FOO = "FOO" +_BAZ = "BAZ" +_BAR = "BAR" +_ONE = "ONE" +_ZERO = "ZERO" +_SIPI = "SimpleInputParamsInput" +_B = "Bar" +_Ba = "Baz" +_Bam = "Bam" +_FV = "FloatValue" +_Bo = "Boo" +_Q = "Qux" +_HQN = "HasQueryName" +_aQN = "aws.protocols#ec2QueryName" +_HQAXN = "HasQueryAndXmlName" +_hQAXN = "hasQueryAndXmlName" +_UXN = "UsesXmlName" +_uXN = "usesXmlName" +_DQN = "DistinctQueryName" +_QN = "QueryName" +_DQAXN = "DistinctQueryAndXmlName" +_qAXN = "queryAndXmlName" +_xAQN = "xmlAndQueryName" +_DXN = "DistinctXmlName" +_xNO = "xmlNameOnly" +_SIPO = "SimpleInputParamsOutput" +_SIP = "SimpleInputParams" +_SSXPI = "SimpleScalarXmlPropertiesInput" +_SSXPO = "SimpleScalarXmlPropertiesOutput" +_sV = "stringValue" +_eSV = "emptyStringValue" +_tBV = "trueBooleanValue" +_fBV = "falseBooleanValue" +_bV = "byteValue" +_sVh = "shortValue" +_iV = "integerValue" +_lV = "longValue" +_fV = "floatValue" +_dV = "doubleValue" +_DD = "DoubleDribble" +_SSXP = "SimpleScalarXmlProperties" +_XBI = "XmlBlobsInput" +_XBOO = "XmlBlobsOperationOutput" +_aXBO = "aws.protocoltests.ec2#XmlBlobsOutput" +_XB = "XmlBlobs" +_XEBI = "XmlEmptyBlobsInput" +_XEBO = "XmlEmptyBlobsOutput" +_XEB = "XmlEmptyBlobs" +_XELI = "XmlEmptyListsInput" +_BL = "BooleanList" +_FEL = "FooEnumList" +_RLM = "RenamedListMembers" +_LWMN = "ListWithMemberNamespace" +_sNm = "smithy.api#xmlNamespace" +_LWN = "ListWithNamespace" +_IL = "IntegerList" +_IE = "IntegerEnum" +_A = "A" +_B_ = "B" +_C = "C" +_IEL = "IntegerEnumList" +_NSL = "NestedStringList" +_SS = "StringSet" +_SLM = "StructureListMember" +_a = "a" +_v = "value" +_b = "b" +_o = "other" +_SLt = "StructureList" +_TLi = "TimestampList" +_XELO = "XmlEmptyListsOutput" +_aXLO = "aws.protocoltests.ec2#XmlListsOutput" +_sLt = "stringList" +_sS = "stringSet" +_iL = "integerList" +_bL = "booleanList" +_tL = "timestampList" +_eL = "enumList" +_iEL = "intEnumList" +_nSL = "nestedStringList" +_rLM = "renamedListMembers" +_r = "renamed" +_fL = "flattenedList" +_sFm = "smithy.api#xmlFlattened" +_fLl = "flattenedList2" +_cN = "customName" +_fLWMN = "flattenedListWithMemberNamespace" +_fLWN = "flattenedListWithNamespace" +_sLtr = "structureList" +_mSL = "myStructureList" +_XEL = "XmlEmptyLists" +_XEI = "XmlEnumsInput" +_FEM = "FooEnumMap" +_k = "key" +_FES = "FooEnumSet" +_XEO = "XmlEnumsOutput" +_fE = "fooEnum1" +_fEo = "fooEnum2" +_fEoo = "fooEnum3" +_fEL = "fooEnumList" +_fES = "fooEnumSet" +_fEM = "fooEnumMap" +_XE = "XmlEnums" +_XIEI = "XmlIntEnumsInput" +_IEM = "IntegerEnumMap" +_IES = "IntegerEnumSet" +_XIEO = "XmlIntEnumsOutput" +_iE = "intEnum1" +_iEn = "intEnum2" +_iEnt = "intEnum3" +_iES = "intEnumSet" +_iEM = "intEnumMap" +_XIE = "XmlIntEnums" +_XLI = "XmlListsInput" +_XLOO = "XmlListsOperationOutput" +_XL = "XmlLists" +_XNI = "XmlNamespacesInput" +_XNL = "XmlNamespacedList" +_XNN = "XmlNamespaceNested" +_va = "values" +_XNO = "XmlNamespacesOutput" +_n = "nested" +_XN = "XmlNamespaces" +_XTI = "XmlTimestampsInput" +_HD = "HttpDate" +_hd = "http-date" +_XTO = "XmlTimestampsOutput" +_no = "normal" +_dT = "dateTime" +_dTOT = "dateTimeOnTarget" +_eS = "epochSeconds" +_eSOT = "epochSecondsOnTarget" +_hD = "httpDate" +_hDOT = "httpDateOnTarget" +_XT = "XmlTimestamps" +_SA = "StructArg" +_SAt = "StringArg" +_OA = "OtherArg" +_RA = "RecursiveArg" +_NSI = "NestedStructuresInput" +_RXSON = "RecursiveXmlShapesOutputNested1" +_RXSONe = "RecursiveXmlShapesOutputNested2" +_ba = "bar" +_rM = "recursiveMember" +_NS = "NestedStructures" +_RXSO = "RecursiveXmlShapesOutput" +_RXS = "RecursiveXmlShapes" +_AE = "AwsEc2" +_aw = "aws.auth#sigv4" +_aQ = "aws.protocols#ec2Query" +_sB = "smithy.rules#endpointBdd" +_aws = "aws.api#service" + +DATETIME_OFFSETS_INPUT = (18, n0, _DOI, {_sSI: _sU}) + +DATE_TIME = (4, n1, _DT, {_sF: _dt}) + +DATETIME_OFFSETS_OUTPUT = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) + +DATETIME_OFFSETS = (23, n0, _DO, 0, DATETIME_OFFSETS_INPUT, DATETIME_OFFSETS_OUTPUT, ()) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n0, _EIAEOI, 0) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n0, _EIAEOO, 0) + +EMPTY_INPUT_AND_EMPTY_OUTPUT = ( + 23, + n0, + _EIAEO, + 0, + EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, + EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + (), +) + +ENDPOINT_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) + +ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) + +ENDPOINT_OPERATION = ( + 23, + n0, + _EO, + {_s: MappingProxyType({"hostPrefix": "foo."})}, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( + 18, + n0, + _EWHLOI, + {_sSI: _aHLI}, + (_l,), + ((3, 257),), +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) + +ENDPOINT_WITH_HOST_LABEL_OPERATION = ( + 23, + n0, + _EWHLO, + {_s: MappingProxyType({"hostPrefix": "foo.{label}."})}, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), +) + +FRACTIONAL_SECONDS_INPUT = (18, n0, _FSI, {_sSI: _sU}) + +FRACTIONAL_SECONDS_OUTPUT = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) + +FRACTIONAL_SECONDS = ( + 23, + n0, + _FS, + 0, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), ) -QUERY_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#QueryListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_LISTS = Schema( - id=ShapeID("aws.protocoltests.ec2#QueryLists"), shape_type=ShapeType.OPERATION -) - -EPOCH_SECONDS = Schema( - id=ShapeID("aws.protocoltests.shared#EpochSeconds"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds")], -) +COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, 0),)) -QUERY_TIMESTAMPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#QueryTimestampsInput"), - members={ - "normalFormat": {"target": TIMESTAMP}, - "epochMember": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochTarget": {"target": EPOCH_SECONDS}, - }, +COMPLEX_ERROR = ( + 18, + n0, + _CE, + {_smi: _c}, + (_TL, _N), + ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -QUERY_TIMESTAMPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#QueryTimestampsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, {_sSI: _sU}) -QUERY_TIMESTAMPS = Schema( - id=ShapeID("aws.protocoltests.ec2#QueryTimestamps"), shape_type=ShapeType.OPERATION -) +GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -RECURSIVE_XML_SHAPES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#RecursiveXmlShapesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +INVALID_GREETING = (18, n0, _IG, {_smi: _c}, (_M,), ((3, 0),)) -FOO_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, +GREETING_WITH_ERRORS = ( + 23, + n0, + _GWE, + 0, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR), ) -SIMPLE_INPUT_PARAMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#SimpleInputParamsInput"), - members={ - "Foo": {"target": STRING}, - "Bar": {"target": STRING}, - "Baz": {"target": BOOLEAN}, - "Bam": {"target": INTEGER}, - "FloatValue": {"target": FLOAT}, - "Boo": {"target": DOUBLE}, - "Qux": {"target": BLOB}, - "FooEnum": {"target": FOO_ENUM}, - "HasQueryName": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("aws.protocols#ec2QueryName"), value="HasQueryName" - ) - ], - }, - "HasQueryAndXmlName": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("aws.protocols#ec2QueryName"), value="HasQueryAndXmlName" - ), - Trait.new(id=ShapeID("smithy.api#xmlName"), value="hasQueryAndXmlName"), - ], - }, - "UsesXmlName": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="usesXmlName") - ], - }, - "DistinctQueryName": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("aws.protocols#ec2QueryName"), value="QueryName") - ], - }, - "DistinctQueryAndXmlName": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("aws.protocols#ec2QueryName"), value="queryAndXmlName" - ), - Trait.new(id=ShapeID("smithy.api#xmlName"), value="xmlAndQueryName"), - ], - }, - "DistinctXmlName": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="xmlNameOnly") - ], - }, - }, -) +HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) -SIMPLE_INPUT_PARAMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#SimpleInputParamsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) -SIMPLE_INPUT_PARAMS = Schema( - id=ShapeID("aws.protocoltests.ec2#SimpleInputParams"), - shape_type=ShapeType.OPERATION, +HOST_WITH_PATH_OPERATION = ( + 23, + n0, + _HWPO, + 0, + HOST_WITH_PATH_OPERATION_INPUT, + HOST_WITH_PATH_OPERATION_OUTPUT, + (), ) -SIMPLE_SCALAR_XML_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#SimpleScalarXmlPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#SimpleScalarXmlPropertiesOutput"), - members={ - "stringValue": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("aws.protocols#ec2QueryName"), value="IgnoreMe") - ], - }, - "emptyStringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="DoubleDribble") - ], - }, - }, -) - -SIMPLE_SCALAR_XML_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.ec2#SimpleScalarXmlProperties"), - shape_type=ShapeType.OPERATION, -) - -XML_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -XML_BLOBS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlBlobsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.ec2#XmlBlobsOutput", - ) - ], - members={"data": {"target": BLOB}}, -) - -XML_BLOBS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlBlobs"), shape_type=ShapeType.OPERATION -) - -XML_EMPTY_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlEmptyBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -XML_EMPTY_BLOBS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlEmptyBlobsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.ec2#XmlBlobsOutput", - ) - ], - members={"data": {"target": BLOB}}, -) - -XML_EMPTY_BLOBS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlEmptyBlobs"), shape_type=ShapeType.OPERATION -) - -XML_EMPTY_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlEmptyListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -BOOLEAN_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#BooleanList"), - shape_type=ShapeType.LIST, - members={"member": {"target": BOOLEAN}}, -) +IGNORES_WRAPPING_XML_NAME_INPUT = (18, n0, _IWXNI, {_sSI: _sU}) -FOO_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) +IGNORES_WRAPPING_XML_NAME_OUTPUT = (18, n0, _IWXNO, {_sN: _IM}, (_f,), ((3, 0),)) -RENAMED_LIST_MEMBERS = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#RenamedListMembers"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, +IGNORES_WRAPPING_XML_NAME = ( + 23, + n0, + _IWXN, + 0, + IGNORES_WRAPPING_XML_NAME_INPUT, + IGNORES_WRAPPING_XML_NAME_OUTPUT, + (), ) -LIST_WITH_MEMBER_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#ListWithMemberNamespace"), - shape_type=ShapeType.LIST, - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-list.example.com"}), - ) - ], - members={ - "member": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-member.example.com"}), - ) - ], - } - }, -) +NESTED_STRUCTURES_OUTPUT = (18, n0, _NSO, {_sSI: _sU}) -LIST_WITH_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#ListWithNamespace"), - shape_type=ShapeType.LIST, - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-list.example.com"}), - ) - ], - members={"member": {"target": STRING}}, -) +NO_INPUT_AND_OUTPUT_INPUT = (18, n0, _NIAOI, {_sSI: _sU}) -INTEGER_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) +NO_INPUT_AND_OUTPUT_OUTPUT = (18, n0, _NIAOO, 0) -INTEGER_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, +NO_INPUT_AND_OUTPUT = ( + 23, + n0, + _NIAO, + 0, + NO_INPUT_AND_OUTPUT_INPUT, + NO_INPUT_AND_OUTPUT_OUTPUT, + (), ) -INTEGER_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, +PUT_WITH_CONTENT_ENCODING_INPUT = ( + 18, + n0, + _PWCEI, + 0, + (_e, _da), + ((3, {_sH: _CE_}), (3, 0)), ) -NESTED_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#NestedStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING_LIST}}, -) +PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) -STRING_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, +PUT_WITH_CONTENT_ENCODING = ( + 23, + n0, + _PWCE, + {_sC: MappingProxyType({"encodings": ("gzip",)})}, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), ) -STRUCTURE_LIST_MEMBER = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#StructureListMember"), - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="value")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="other")], - }, - }, -) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = (18, n0, _QITAFI, 0, (_t,), ((3, 2),)) -STRUCTURE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#StructureList"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRUCTURE_LIST_MEMBER, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, -) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n0, _QITAFO, {_sSI: _sU}) -TIMESTAMP_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#TimestampList"), - shape_type=ShapeType.LIST, - members={"member": {"target": TIMESTAMP}}, +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( + 23, + n0, + _QITAF, + 0, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + (), ) -XML_EMPTY_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlEmptyListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.ec2#XmlListsOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - }, -) +GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) -XML_EMPTY_LISTS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlEmptyLists"), shape_type=ShapeType.OPERATION -) +GREETING_LIST = (16, n1, _GL, 0, (_m,), ((GREETING_STRUCT, 0),)) -XML_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) -FOO_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": FOO_ENUM}}, -) +LIST_WITH_XML_NAME = (16, n0, _LWXN, 0, (_m,), ((3, {_sN: _i}),)) + +NESTED_STRUCT_WITH_LIST = (18, n0, _NSWL, 0, (_LA,), ((STRING_LIST, 0),)) + +QUERY_LISTS_INPUT = ( + 18, + n0, + _QLI, + 0, + (_LA, _CLA, _LAWXNM, _LAWXN, _NWL), + ( + (STRING_LIST, 0), + (GREETING_LIST, 0), + (LIST_WITH_XML_NAME, 0), + (LIST_WITH_XML_NAME, {_sN: _H}), + (NESTED_STRUCT_WITH_LIST, 0), + ), +) + +QUERY_LISTS_OUTPUT = (18, n0, _QLO, {_sSI: _sU}) + +QUERY_LISTS = (23, n0, _QL, 0, QUERY_LISTS_INPUT, QUERY_LISTS_OUTPUT, ()) -FOO_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) +EPOCH_SECONDS = (4, n1, _ES, {_sF: _es}) -XML_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlEnumsOutput"), - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, +QUERY_TIMESTAMPS_INPUT = ( + 18, + n0, + _QTI, + 0, + (_nF, _eM, _eT), + ((4, 0), (4, {_sF: _es}), (EPOCH_SECONDS, 0)), ) -XML_ENUMS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlEnums"), shape_type=ShapeType.OPERATION -) +QUERY_TIMESTAMPS_OUTPUT = (18, n0, _QTO, {_sSI: _sU}) -XML_INT_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlIntEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +QUERY_TIMESTAMPS = (23, n0, _QT, 0, QUERY_TIMESTAMPS_INPUT, QUERY_TIMESTAMPS_OUTPUT, ()) -INTEGER_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER_ENUM}}, -) +RECURSIVE_XML_SHAPES_INPUT = (18, n0, _RXSI, {_sSI: _sU}) -INTEGER_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, +FOO_ENUM = ( + 14, + n1, + _FE, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -XML_INT_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlIntEnumsOutput"), - members={ - "intEnum1": {"target": INTEGER_ENUM}, - "intEnum2": {"target": INTEGER_ENUM}, - "intEnum3": {"target": INTEGER_ENUM}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "intEnumSet": {"target": INTEGER_ENUM_SET}, - "intEnumMap": {"target": INTEGER_ENUM_MAP}, - }, +SIMPLE_INPUT_PARAMS_INPUT = ( + 18, + n0, + _SIPI, + 0, + (_F, _B, _Ba, _Bam, _FV, _Bo, _Q, _FE, _HQN, _HQAXN, _UXN, _DQN, _DQAXN, _DXN), + ( + (3, 0), + (3, 0), + (2, 0), + (7, 0), + (9, 0), + (10, 0), + (1, 0), + (FOO_ENUM, 0), + (3, {_aQN: _HQN}), + (3, {_aQN: _HQAXN, _sN: _hQAXN}), + (3, {_sN: _uXN}), + (3, {_aQN: _QN}), + (3, {_aQN: _qAXN, _sN: _xAQN}), + (3, {_sN: _xNO}), + ), ) -XML_INT_ENUMS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlIntEnums"), shape_type=ShapeType.OPERATION -) +SIMPLE_INPUT_PARAMS_OUTPUT = (18, n0, _SIPO, {_sSI: _sU}) -XML_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +SIMPLE_INPUT_PARAMS = ( + 23, + n0, + _SIP, + 0, + SIMPLE_INPUT_PARAMS_INPUT, + SIMPLE_INPUT_PARAMS_OUTPUT, + (), ) -XML_LISTS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlListsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.ec2#XmlListsOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - }, -) +SIMPLE_SCALAR_XML_PROPERTIES_INPUT = (18, n0, _SSXPI, {_sSI: _sU}) -XML_LISTS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlLists"), shape_type=ShapeType.OPERATION +SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT = ( + 18, + n0, + _SSXPO, + 0, + (_sV, _eSV, _tBV, _fBV, _bV, _sVh, _iV, _lV, _fV, _dV), + ( + (3, {_aQN: _IM}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_sN: _DD}), + ), ) -XML_NAMESPACES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlNamespacesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +SIMPLE_SCALAR_XML_PROPERTIES = ( + 23, + n0, + _SSXP, + 0, + SIMPLE_SCALAR_XML_PROPERTIES_INPUT, + SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, + (), ) -XML_NAMESPACED_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlNamespacedList"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://bux.com"}), - ) - ], - } - }, -) +XML_BLOBS_INPUT = (18, n0, _XBI, {_sSI: _sU}) -XML_NAMESPACE_NESTED = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlNamespaceNested"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://baz.com", "prefix": "baz"}), - ) - ], - }, - "values": { - "target": XML_NAMESPACED_LIST, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://qux.com"}), - ) - ], - }, - }, -) +XML_BLOBS_OPERATION_OUTPUT = (18, n0, _XBOO, {_sSI: _aXBO}, (_da,), ((1, 0),)) -XML_NAMESPACES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlNamespacesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ) - ], - members={"nested": {"target": XML_NAMESPACE_NESTED}}, -) +XML_BLOBS = (23, n0, _XB, 0, XML_BLOBS_INPUT, XML_BLOBS_OPERATION_OUTPUT, ()) -XML_NAMESPACES = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlNamespaces"), shape_type=ShapeType.OPERATION -) +XML_EMPTY_BLOBS_INPUT = (18, n0, _XEBI, {_sSI: _sU}) -XML_TIMESTAMPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlTimestampsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +XML_EMPTY_BLOBS_OUTPUT = (18, n0, _XEBO, {_sSI: _aXBO}, (_da,), ((1, 0),)) -HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.shared#HttpDate"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date")], -) +XML_EMPTY_BLOBS = (23, n0, _XEB, 0, XML_EMPTY_BLOBS_INPUT, XML_EMPTY_BLOBS_OUTPUT, ()) -XML_TIMESTAMPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#XmlTimestampsOutput"), - members={ - "normal": {"target": TIMESTAMP}, - "dateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "dateTimeOnTarget": {"target": DATE_TIME}, - "epochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochSecondsOnTarget": {"target": EPOCH_SECONDS}, - "httpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "httpDateOnTarget": {"target": HTTP_DATE}, - }, -) +XML_EMPTY_LISTS_INPUT = (18, n0, _XELI, {_sSI: _sU}) -XML_TIMESTAMPS = Schema( - id=ShapeID("aws.protocoltests.ec2#XmlTimestamps"), shape_type=ShapeType.OPERATION -) +BOOLEAN_LIST = (16, n1, _BL, 0, (_m,), ((2, 0),)) -STRUCT_ARG = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#StructArg"), - members={ - "StringArg": {"target": STRING}, - "OtherArg": {"target": BOOLEAN}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "RecursiveArg": None, - }, -) +FOO_ENUM_LIST = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) + +RENAMED_LIST_MEMBERS = (16, n0, _RLM, 0, (_m,), ((3, {_sN: _i}),)) + +LIST_WITH_MEMBER_NAMESPACE = ( + 16, + n0, + _LWMN, + {_sNm: MappingProxyType({"uri": "https://xml-list.example.com"})}, + (_m,), + ((3, {_sNm: MappingProxyType({"uri": "https://xml-member.example.com"})}),), +) + +LIST_WITH_NAMESPACE = ( + 16, + n0, + _LWN, + {_sNm: MappingProxyType({"uri": "https://xml-list.example.com"})}, + (_m,), + ((3, 0),), +) + +INTEGER_LIST = (16, n1, _IL, 0, (_m,), ((7, 0),)) + +INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B_, _C), ((-1, 0), (-1, 0), (-1, 0))) + +INTEGER_ENUM_LIST = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) + +NESTED_STRING_LIST = (16, n1, _NSL, 0, (_m,), ((STRING_LIST, 0),)) + +STRING_SET = (16, n1, _SS, 0, (_m,), ((3, 0),)) + +STRUCTURE_LIST_MEMBER = (18, n0, _SLM, 0, (_a, _b), ((3, {_sN: _v}), (3, {_sN: _o}))) + +STRUCTURE_LIST = (16, n0, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, {_sN: _i}),)) + +TIMESTAMP_LIST = (16, n1, _TLi, 0, (_m,), ((4, 0),)) -NESTED_STRUCTURES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#NestedStructuresInput"), - members={"Nested": {"target": STRUCT_ARG}}, -) +XML_EMPTY_LISTS_OUTPUT = ( + 18, + n0, + _XELO, + {_sSI: _aXLO}, + (_sLt, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _rLM, _fL, _fLl, _fLWMN, _fLWN, _sLtr), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + ), +) + +XML_EMPTY_LISTS = (23, n0, _XEL, 0, XML_EMPTY_LISTS_INPUT, XML_EMPTY_LISTS_OUTPUT, ()) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#RecursiveXmlShapesOutputNested1"), - members={ - "foo": {"target": STRING}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "nested": None, - }, -) +XML_ENUMS_INPUT = (18, n0, _XEI, {_sSI: _sU}) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#RecursiveXmlShapesOutputNested2"), - members={ - "bar": {"target": STRING}, - "recursiveMember": {"target": RECURSIVE_XML_SHAPES_OUTPUT_NESTED1}, - }, -) +FOO_ENUM_MAP = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -NESTED_STRUCTURES = Schema( - id=ShapeID("aws.protocoltests.ec2#NestedStructures"), shape_type=ShapeType.OPERATION -) +FOO_ENUM_SET = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -RECURSIVE_XML_SHAPES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.ec2#RecursiveXmlShapesOutput"), - members={"nested": {"target": RECURSIVE_XML_SHAPES_OUTPUT_NESTED1}}, +XML_ENUMS_OUTPUT = ( + 18, + n0, + _XEO, + 0, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -RECURSIVE_XML_SHAPES = Schema( - id=ShapeID("aws.protocoltests.ec2#RecursiveXmlShapes"), - shape_type=ShapeType.OPERATION, -) +XML_ENUMS = (23, n0, _XE, 0, XML_ENUMS_INPUT, XML_ENUMS_OUTPUT, ()) -AWS_EC2 = Schema( - id=ShapeID("aws.protocoltests.ec2#AwsEc2"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), value=MappingProxyType({"name": "ec2query"}) - ), - Trait.new(id=ShapeID("aws.protocols#ec2Query")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( +XML_INT_ENUMS_INPUT = (18, n0, _XIEI, {_sSI: _sU}) + +INTEGER_ENUM_MAP = (17, n1, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) + +INTEGER_ENUM_SET = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) + +XML_INT_ENUMS_OUTPUT = ( + 18, + n0, + _XIEO, + 0, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), +) + +XML_INT_ENUMS = (23, n0, _XIE, 0, XML_INT_ENUMS_INPUT, XML_INT_ENUMS_OUTPUT, ()) + +XML_LISTS_INPUT = (18, n0, _XLI, {_sSI: _sU}) + +XML_LISTS_OPERATION_OUTPUT = ( + 18, + n0, + _XLOO, + {_sSI: _aXLO}, + (_sLt, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _rLM, _fL, _fLl, _fLWMN, _fLWN, _sLtr), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + ), +) + +XML_LISTS = (23, n0, _XL, 0, XML_LISTS_INPUT, XML_LISTS_OPERATION_OUTPUT, ()) + +XML_NAMESPACES_INPUT = (18, n0, _XNI, {_sSI: _sU}) + +XML_NAMESPACED_LIST = ( + 16, + n0, + _XNL, + 0, + (_m,), + ((3, {_sNm: MappingProxyType({"uri": "http://bux.com"})}),), +) + +XML_NAMESPACE_NESTED = ( + 18, + n0, + _XNN, + {_sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_f, _va), + ( + (3, {_sNm: MappingProxyType({"uri": "http://baz.com", "prefix": "baz"})}), + (XML_NAMESPACED_LIST, {_sNm: MappingProxyType({"uri": "http://qux.com"})}), + ), +) + +XML_NAMESPACES_OUTPUT = ( + 18, + n0, + _XNO, + {_sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_n,), + ((XML_NAMESPACE_NESTED, 0),), +) + +XML_NAMESPACES = (23, n0, _XN, 0, XML_NAMESPACES_INPUT, XML_NAMESPACES_OUTPUT, ()) + +XML_TIMESTAMPS_INPUT = (18, n0, _XTI, {_sSI: _sU}) + +HTTP_DATE = (4, n1, _HD, {_sF: _hd}) + +XML_TIMESTAMPS_OUTPUT = ( + 18, + n0, + _XTO, + 0, + (_no, _dT, _dTOT, _eS, _eSOT, _hD, _hDOT), + ( + (4, 0), + (4, {_sF: _dt}), + (DATE_TIME, 0), + (4, {_sF: _es}), + (EPOCH_SECONDS, 0), + (4, {_sF: _hd}), + (HTTP_DATE, 0), + ), +) + +XML_TIMESTAMPS = (23, n0, _XT, 0, XML_TIMESTAMPS_INPUT, XML_TIMESTAMPS_OUTPUT, ()) + +STRUCT_ARG = ( + 18, + n0, + _SA, + 0, + (_SAt, _OA, _RA), + ((3, 0), (2, 0), (lambda: STRUCT_ARG, 0)), +) + +NESTED_STRUCTURES_INPUT = (18, n0, _NSI, 0, (_N,), ((STRUCT_ARG, 0),)) + +RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( + 18, + n0, + _RXSON, + 0, + (_f, _n), + ((3, 0), (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0)), +) + +RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( + 18, + n0, + _RXSONe, + 0, + (_ba, _rM), + ((3, 0), (RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0)), +) + +NESTED_STRUCTURES = ( + 23, + n0, + _NS, + 0, + NESTED_STRUCTURES_INPUT, + NESTED_STRUCTURES_OUTPUT, + (), +) + +RECURSIVE_XML_SHAPES_OUTPUT = ( + 18, + n0, + _RXSO, + 0, + (_n,), + ((RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_XML_SHAPES = ( + 23, + n0, + _RXS, + 0, + RECURSIVE_XML_SHAPES_INPUT, + RECURSIVE_XML_SHAPES_OUTPUT, + (), +) + +AWS_EC2 = ( + 21, + n0, + _AE, + { + _aw: MappingProxyType({"name": "ec2query"}), + _aQ: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://awsec2-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://awsec2.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://awsec2-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://awsec2.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://awsec2.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), - ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType({"sdkId": "EC2 Protocol"}), - ), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://example.com/"}), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsec2-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsec2.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsec2-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsec2.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://awsec2.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - ], -) - -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["nested"] = Schema.member( - id=RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.id.with_member("nested"), - target=RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, - index=1, -) - -STRUCT_ARG.members["RecursiveArg"] = Schema.member( - id=STRUCT_ARG.id.with_member("RecursiveArg"), target=STRUCT_ARG, index=2 + _aws: MappingProxyType({"sdkId": "EC2 Protocol"}), + _sNm: MappingProxyType({"uri": "https://example.com/"}), + }, ) diff --git a/codegen-output/ec2-query/src/ec2query/models.py b/codegen-output/ec2-query/src/ec2query/models.py index 6c3eb21e9..86db4973e 100644 --- a/codegen-output/ec2-query/src/ec2query/models.py +++ b/codegen-output/ec2-query/src/ec2query/models.py @@ -6,6 +6,7 @@ import logging from typing import Any, Literal, Self +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import TypeRegistry from smithy_core.exceptions import ModeledError @@ -121,7 +122,7 @@ class DatetimeOffsetsInput: """Dataclass for DatetimeOffsetsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -133,13 +134,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -160,13 +162,12 @@ class DatetimeOffsetsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -175,30 +176,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DATETIME_OFFSETS = APIOperation( input=DatetimeOffsetsInput, output=DatetimeOffsetsOutput, - schema=_SCHEMA_DATETIME_OFFSETS, - input_schema=_SCHEMA_DATETIME_OFFSETS_INPUT, - output_schema=_SCHEMA_DATETIME_OFFSETS_OUTPUT, + static_schema=_SCHEMA_DATETIME_OFFSETS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -207,7 +205,9 @@ class EmptyInputAndEmptyOutputInput: """Dataclass for EmptyInputAndEmptyOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -219,15 +219,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -246,7 +245,9 @@ class EmptyInputAndEmptyOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -258,27 +259,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_INPUT_AND_EMPTY_OUTPUT = APIOperation( input=EmptyInputAndEmptyOutputInput, output=EmptyInputAndEmptyOutputOutput, - schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, - input_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, - output_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + static_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -287,7 +284,7 @@ class EndpointOperationInput: """Dataclass for EndpointOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -299,13 +296,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -324,7 +322,7 @@ class EndpointOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -336,25 +334,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_OPERATION = APIOperation( input=EndpointOperationInput, output=EndpointOperationOutput, - schema=_SCHEMA_ENDPOINT_OPERATION, - input_schema=_SCHEMA_ENDPOINT_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -365,14 +361,16 @@ class EndpointWithHostLabelOperationInput: label: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT + ).members_by_index if self.label is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members["label"], - self.label, - ) + serializer.write_string(members[0], self.label) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -381,22 +379,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["label"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members[ - "label" - ] - ) + kwargs["label"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -415,7 +409,9 @@ class EndpointWithHostLabelOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -427,27 +423,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_OPERATION = APIOperation( input=EndpointWithHostLabelOperationInput, output=EndpointWithHostLabelOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -456,7 +448,7 @@ class FractionalSecondsInput: """Dataclass for FractionalSecondsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -468,13 +460,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -495,13 +488,12 @@ class FractionalSecondsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -510,30 +502,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FRACTIONAL_SECONDS = APIOperation( input=FractionalSecondsInput, output=FractionalSecondsOutput, - schema=_SCHEMA_FRACTIONAL_SECONDS, - input_schema=_SCHEMA_FRACTIONAL_SECONDS_INPUT, - output_schema=_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, + static_schema=_SCHEMA_FRACTIONAL_SECONDS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -544,13 +533,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -559,18 +547,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -585,18 +573,15 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[0], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -605,21 +590,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[0]) case 1: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -628,7 +613,7 @@ class GreetingWithErrorsInput: """Dataclass for GreetingWithErrorsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -640,13 +625,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -667,13 +653,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -682,20 +667,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -706,13 +689,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -721,27 +703,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.ec2#InvalidGreeting"): InvalidGreeting, @@ -749,7 +729,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_INVALID_GREETING, _SCHEMA_COMPLEX_ERROR], ) @@ -758,7 +737,7 @@ class HostWithPathOperationInput: """Dataclass for HostWithPathOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -770,15 +749,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -797,7 +775,7 @@ class HostWithPathOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -809,27 +787,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HOST_WITH_PATH_OPERATION = APIOperation( input=HostWithPathOperationInput, output=HostWithPathOperationOutput, - schema=_SCHEMA_HOST_WITH_PATH_OPERATION, - input_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, - output_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, + static_schema=_SCHEMA_HOST_WITH_PATH_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -838,7 +812,7 @@ class IgnoresWrappingXmlNameInput: """Dataclass for IgnoresWrappingXmlNameInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -850,15 +824,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -879,13 +852,12 @@ class IgnoresWrappingXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -894,32 +866,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs IGNORES_WRAPPING_XML_NAME = APIOperation( input=IgnoresWrappingXmlNameInput, output=IgnoresWrappingXmlNameOutput, - schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME, - input_schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME_INPUT, - output_schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME_OUTPUT, + static_schema=_SCHEMA_IGNORES_WRAPPING_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -938,7 +905,7 @@ class NestedStructuresOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCTURES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCTURES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -950,13 +917,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCTURES_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCTURES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -965,7 +933,7 @@ class NoInputAndOutputInput: """Dataclass for NoInputAndOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -977,13 +945,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1002,7 +971,7 @@ class NoInputAndOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1014,25 +983,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_OUTPUT = APIOperation( input=NoInputAndOutputInput, output=NoInputAndOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1045,19 +1012,15 @@ class PutWithContentEncodingInput: data: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT).members_by_index if self.encoding is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"], - self.encoding, - ) + serializer.write_string(members[0], self.encoding) if self.data is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"], self.data - ) + serializer.write_string(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1066,25 +1029,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["encoding"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"] - ) + kwargs["encoding"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"] - ) + kwargs["data"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1103,7 +1062,7 @@ class PutWithContentEncodingOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1115,27 +1074,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_WITH_CONTENT_ENCODING = APIOperation( input=PutWithContentEncodingInput, output=PutWithContentEncodingOutput, - schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, - input_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, - output_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, + static_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1146,14 +1101,16 @@ class QueryIdempotencyTokenAutoFillInput: token: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT + ).members_by_index if self.token is not None: - serializer.write_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"], - self.token, - ) + serializer.write_string(members[0], self.token) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1162,20 +1119,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["token"] = de.read_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"] - ) + kwargs["token"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1194,7 +1149,9 @@ class QueryIdempotencyTokenAutoFillOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1206,27 +1163,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = APIOperation( input=QueryIdempotencyTokenAutoFillInput, output=QueryIdempotencyTokenAutoFillOutput, - schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, - input_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, - output_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + static_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1237,11 +1190,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1250,23 +1204,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_greeting_list( serializer: ShapeSerializer, schema: Schema, value: list[GreetingStruct] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -1291,7 +1247,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1301,7 +1257,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1317,7 +1273,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_xml_name( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1327,7 +1283,7 @@ def _deserialize_list_with_xml_name( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1347,15 +1303,12 @@ class NestedStructWithList: list_arg: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCT_WITH_LIST, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCT_WITH_LIST), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_STRUCT_WITH_LIST).members_by_index if self.list_arg is not None: - _serialize_string_list( - serializer, - _SCHEMA_NESTED_STRUCT_WITH_LIST.members["ListArg"], - self.list_arg, - ) + _serialize_string_list(serializer, members[0], self.list_arg) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1364,18 +1317,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCT_WITH_LIST) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["list_arg"] = _deserialize_string_list( - de, _SCHEMA_NESTED_STRUCT_WITH_LIST.members["ListArg"] - ) + kwargs["list_arg"] = _deserialize_string_list(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCT_WITH_LIST, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1394,40 +1347,28 @@ class QueryListsInput: nested_with_list: NestedStructWithList | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_LISTS_INPUT).members_by_index if self.list_arg is not None: - _serialize_string_list( - serializer, _SCHEMA_QUERY_LISTS_INPUT.members["ListArg"], self.list_arg - ) + _serialize_string_list(serializer, members[0], self.list_arg) if self.complex_list_arg is not None: - _serialize_greeting_list( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["ComplexListArg"], - self.complex_list_arg, - ) + _serialize_greeting_list(serializer, members[1], self.complex_list_arg) if self.list_arg_with_xml_name_member is not None: _serialize_list_with_xml_name( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["ListArgWithXmlNameMember"], - self.list_arg_with_xml_name_member, + serializer, members[2], self.list_arg_with_xml_name_member ) if self.list_arg_with_xml_name is not None: _serialize_list_with_xml_name( - serializer, - _SCHEMA_QUERY_LISTS_INPUT.members["ListArgWithXmlName"], - self.list_arg_with_xml_name, + serializer, members[3], self.list_arg_with_xml_name ) if self.nested_with_list is not None: - serializer.write_struct( - _SCHEMA_QUERY_LISTS_INPUT.members["NestedWithList"], - self.nested_with_list, - ) + serializer.write_struct(members[4], self.nested_with_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1436,41 +1377,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["list_arg"] = _deserialize_string_list( - de, _SCHEMA_QUERY_LISTS_INPUT.members["ListArg"] - ) + kwargs["list_arg"] = _deserialize_string_list(de, members[0]) case 1: kwargs["complex_list_arg"] = _deserialize_greeting_list( - de, _SCHEMA_QUERY_LISTS_INPUT.members["ComplexListArg"] + de, members[1] ) case 2: kwargs["list_arg_with_xml_name_member"] = ( - _deserialize_list_with_xml_name( - de, - _SCHEMA_QUERY_LISTS_INPUT.members[ - "ListArgWithXmlNameMember" - ], - ) + _deserialize_list_with_xml_name(de, members[2]) ) case 3: kwargs["list_arg_with_xml_name"] = _deserialize_list_with_xml_name( - de, _SCHEMA_QUERY_LISTS_INPUT.members["ListArgWithXmlName"] + de, members[3] ) case 4: kwargs["nested_with_list"] = NestedStructWithList.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1489,7 +1425,7 @@ class QueryListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1501,25 +1437,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_LISTS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_LISTS = APIOperation( input=QueryListsInput, output=QueryListsOutput, - schema=_SCHEMA_QUERY_LISTS, - input_schema=_SCHEMA_QUERY_LISTS_INPUT, - output_schema=_SCHEMA_QUERY_LISTS_OUTPUT, + static_schema=_SCHEMA_QUERY_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1534,24 +1468,18 @@ class QueryTimestampsInput: epoch_target: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_TIMESTAMPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_TIMESTAMPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_TIMESTAMPS_INPUT).members_by_index if self.normal_format is not None: - serializer.write_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["normalFormat"], - self.normal_format, - ) + serializer.write_timestamp(members[0], self.normal_format) if self.epoch_member is not None: - serializer.write_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochMember"], self.epoch_member - ) + serializer.write_timestamp(members[1], self.epoch_member) if self.epoch_target is not None: - serializer.write_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochTarget"], self.epoch_target - ) + serializer.write_timestamp(members[2], self.epoch_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1560,28 +1488,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_TIMESTAMPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal_format"] = de.read_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["normalFormat"] - ) + kwargs["normal_format"] = de.read_timestamp(members[0]) case 1: - kwargs["epoch_member"] = de.read_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochMember"] - ) + kwargs["epoch_member"] = de.read_timestamp(members[1]) case 2: - kwargs["epoch_target"] = de.read_timestamp( - _SCHEMA_QUERY_TIMESTAMPS_INPUT.members["epochTarget"] - ) + kwargs["epoch_target"] = de.read_timestamp(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_TIMESTAMPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1600,7 +1524,7 @@ class QueryTimestampsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1612,25 +1536,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_TIMESTAMPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_TIMESTAMPS = APIOperation( input=QueryTimestampsInput, output=QueryTimestampsOutput, - schema=_SCHEMA_QUERY_TIMESTAMPS, - input_schema=_SCHEMA_QUERY_TIMESTAMPS_INPUT, - output_schema=_SCHEMA_QUERY_TIMESTAMPS_OUTPUT, + static_schema=_SCHEMA_QUERY_TIMESTAMPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1639,7 +1561,7 @@ class RecursiveXmlShapesInput: """Dataclass for RecursiveXmlShapesInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1651,13 +1573,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_XML_SHAPES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1702,85 +1625,51 @@ class SimpleInputParamsInput: distinct_xml_name: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.bar is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bar"], self.bar - ) + serializer.write_string(members[1], self.bar) if self.baz is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Baz"], self.baz - ) + serializer.write_boolean(members[2], self.baz) if self.bam is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bam"], self.bam - ) + serializer.write_integer(members[3], self.bam) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FloatValue"], - self.float_value, - ) + serializer.write_float(members[4], self.float_value) if self.boo is not None: - serializer.write_double( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Boo"], self.boo - ) + serializer.write_double(members[5], self.boo) if self.qux is not None: - serializer.write_blob( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Qux"], self.qux - ) + serializer.write_blob(members[6], self.qux) if self.foo_enum is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FooEnum"], self.foo_enum - ) + serializer.write_string(members[7], self.foo_enum) if self.has_query_name is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["HasQueryName"], - self.has_query_name, - ) + serializer.write_string(members[8], self.has_query_name) if self.has_query_and_xml_name is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["HasQueryAndXmlName"], - self.has_query_and_xml_name, - ) + serializer.write_string(members[9], self.has_query_and_xml_name) if self.uses_xml_name is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["UsesXmlName"], - self.uses_xml_name, - ) + serializer.write_string(members[10], self.uses_xml_name) if self.distinct_query_name is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["DistinctQueryName"], - self.distinct_query_name, - ) + serializer.write_string(members[11], self.distinct_query_name) if self.distinct_query_and_xml_name is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["DistinctQueryAndXmlName"], - self.distinct_query_and_xml_name, - ) + serializer.write_string(members[12], self.distinct_query_and_xml_name) if self.distinct_xml_name is not None: - serializer.write_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["DistinctXmlName"], - self.distinct_xml_name, - ) + serializer.write_string(members[13], self.distinct_xml_name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1789,87 +1678,57 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["bar"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bar"] - ) + kwargs["bar"] = de.read_string(members[1]) case 2: - kwargs["baz"] = de.read_boolean( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Baz"] - ) + kwargs["baz"] = de.read_boolean(members[2]) case 3: - kwargs["bam"] = de.read_integer( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Bam"] - ) + kwargs["bam"] = de.read_integer(members[3]) case 4: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FloatValue"] - ) + kwargs["float_value"] = de.read_float(members[4]) case 5: - kwargs["boo"] = de.read_double( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Boo"] - ) + kwargs["boo"] = de.read_double(members[5]) case 6: - kwargs["qux"] = de.read_blob( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["Qux"] - ) + kwargs["qux"] = de.read_blob(members[6]) case 7: - kwargs["foo_enum"] = FooEnum( - de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["FooEnum"] - ) - ) + kwargs["foo_enum"] = FooEnum(de.read_string(members[7])) case 8: - kwargs["has_query_name"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["HasQueryName"] - ) + kwargs["has_query_name"] = de.read_string(members[8]) case 9: - kwargs["has_query_and_xml_name"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["HasQueryAndXmlName"] - ) + kwargs["has_query_and_xml_name"] = de.read_string(members[9]) case 10: - kwargs["uses_xml_name"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["UsesXmlName"] - ) + kwargs["uses_xml_name"] = de.read_string(members[10]) case 11: - kwargs["distinct_query_name"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["DistinctQueryName"] - ) + kwargs["distinct_query_name"] = de.read_string(members[11]) case 12: - kwargs["distinct_query_and_xml_name"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members[ - "DistinctQueryAndXmlName" - ] - ) + kwargs["distinct_query_and_xml_name"] = de.read_string(members[12]) case 13: - kwargs["distinct_xml_name"] = de.read_string( - _SCHEMA_SIMPLE_INPUT_PARAMS_INPUT.members["DistinctXmlName"] - ) + kwargs["distinct_xml_name"] = de.read_string(members[13]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1888,7 +1747,7 @@ class SimpleInputParamsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1900,25 +1759,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_INPUT_PARAMS = APIOperation( input=SimpleInputParamsInput, output=SimpleInputParamsOutput, - schema=_SCHEMA_SIMPLE_INPUT_PARAMS, - input_schema=_SCHEMA_SIMPLE_INPUT_PARAMS_INPUT, - output_schema=_SCHEMA_SIMPLE_INPUT_PARAMS_OUTPUT, + static_schema=_SCHEMA_SIMPLE_INPUT_PARAMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1927,7 +1784,9 @@ class SimpleScalarXmlPropertiesInput: """Dataclass for SimpleScalarXmlPropertiesInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1939,15 +1798,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1986,70 +1844,41 @@ class SimpleScalarXmlPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT).members_by_index if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[0], self.string_value) if self.empty_string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["emptyStringValue"], - self.empty_string_value, - ) + serializer.write_string(members[1], self.empty_string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[9], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2058,93 +1887,54 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "stringValue" - ] - ) + kwargs["string_value"] = de.read_string(members[0]) case 1: - kwargs["empty_string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "emptyStringValue" - ] - ) + kwargs["empty_string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "shortValue" - ] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "integerValue" - ] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "floatValue" - ] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT.members[ - "doubleValue" - ] - ) + kwargs["double_value"] = de.read_double(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_XML_PROPERTIES = APIOperation( input=SimpleScalarXmlPropertiesInput, output=SimpleScalarXmlPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_XML_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2153,7 +1943,7 @@ class XmlBlobsInput: """Dataclass for XmlBlobsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2165,13 +1955,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_BLOBS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2192,13 +1983,12 @@ class XmlBlobsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob( - _SCHEMA_XML_BLOBS_OPERATION_OUTPUT.members["data"], self.data - ) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2207,30 +1997,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_BLOBS_OPERATION_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_BLOBS_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_BLOBS = APIOperation( input=XmlBlobsInput, output=XmlBlobsOperationOutput, - schema=_SCHEMA_XML_BLOBS, - input_schema=_SCHEMA_XML_BLOBS_INPUT, - output_schema=_SCHEMA_XML_BLOBS_OPERATION_OUTPUT, + static_schema=_SCHEMA_XML_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2239,7 +2026,7 @@ class XmlEmptyBlobsInput: """Dataclass for XmlEmptyBlobsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2251,13 +2038,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2278,13 +2066,12 @@ class XmlEmptyBlobsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob( - _SCHEMA_XML_EMPTY_BLOBS_OUTPUT.members["data"], self.data - ) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2293,30 +2080,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_EMPTY_BLOBS_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_BLOBS = APIOperation( input=XmlEmptyBlobsInput, output=XmlEmptyBlobsOutput, - schema=_SCHEMA_XML_EMPTY_BLOBS, - input_schema=_SCHEMA_XML_EMPTY_BLOBS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2325,7 +2109,7 @@ class XmlEmptyListsInput: """Dataclass for XmlEmptyListsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2337,20 +2121,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_boolean_list( serializer: ShapeSerializer, schema: Schema, value: list[bool] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_boolean(member_schema, e) @@ -2360,7 +2145,7 @@ def _deserialize_boolean_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[bool]: result: list[bool] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2376,7 +2161,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_foo_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2386,7 +2171,7 @@ def _deserialize_foo_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2402,7 +2187,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_renamed_list_members( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2412,7 +2197,7 @@ def _deserialize_renamed_list_members( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2428,7 +2213,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_member_namespace( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2438,7 +2223,7 @@ def _deserialize_list_with_member_namespace( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2454,7 +2239,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_namespace( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2464,7 +2249,7 @@ def _deserialize_list_with_namespace( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2480,7 +2265,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -2490,7 +2275,7 @@ def _deserialize_integer_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2512,7 +2297,7 @@ class IntegerEnum(UnknownEnumMixin, IntEnum): def _serialize_integer_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -2522,7 +2307,7 @@ def _deserialize_integer_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2538,7 +2323,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_nested_string_list( serializer: ShapeSerializer, schema: Schema, value: list[list[str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_string_list(ls, member_schema, e) @@ -2548,7 +2333,7 @@ def _deserialize_nested_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[list[str]]: result: list[list[str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2564,7 +2349,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2574,7 +2359,7 @@ def _deserialize_string_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2596,14 +2381,15 @@ class StructureListMember: b: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER).members_by_index if self.a is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["a"], self.a) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["b"], self.b) + serializer.write_string(members[1], self.b) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2612,30 +2398,28 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_structure_list( serializer: ShapeSerializer, schema: Schema, value: list[StructureListMember] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2660,7 +2444,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_timestamp_list( serializer: ShapeSerializer, schema: Schema, value: list[datetime] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_timestamp(member_schema, e) @@ -2670,7 +2454,7 @@ def _deserialize_timestamp_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[datetime]: result: list[datetime] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2727,108 +2511,61 @@ class XmlEmptyListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedListWithNamespace"], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2837,105 +2574,84 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["renamedListMembers"] + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["structureList"] + de, members[13] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_LISTS = APIOperation( input=XmlEmptyListsInput, output=XmlEmptyListsOutput, - schema=_SCHEMA_XML_EMPTY_LISTS, - input_schema=_SCHEMA_XML_EMPTY_LISTS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_LISTS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2944,7 +2660,7 @@ class XmlEnumsInput: """Dataclass for XmlEnumsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2956,13 +2672,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ENUMS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2970,7 +2687,7 @@ def _serialize_foo_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2979,7 +2696,7 @@ def _deserialize_foo_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2995,7 +2712,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_foo_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3005,7 +2722,7 @@ def _deserialize_foo_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3045,44 +2762,27 @@ class XmlEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ENUMS_OUTPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3091,55 +2791,42 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_ENUMS = APIOperation( input=XmlEnumsInput, output=XmlEnumsOutput, - schema=_SCHEMA_XML_ENUMS, - input_schema=_SCHEMA_XML_ENUMS_INPUT, - output_schema=_SCHEMA_XML_ENUMS_OUTPUT, + static_schema=_SCHEMA_XML_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3148,7 +2835,7 @@ class XmlIntEnumsInput: """Dataclass for XmlIntEnumsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_INT_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_INT_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3160,13 +2847,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_INT_ENUMS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_INT_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3174,7 +2862,7 @@ def _serialize_integer_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -3183,7 +2871,7 @@ def _deserialize_integer_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -3199,7 +2887,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_integer_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -3209,7 +2897,7 @@ def _deserialize_integer_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3249,44 +2937,27 @@ class XmlIntEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_INT_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT).members_by_index if self.int_enum1 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum1"], self.int_enum1 - ) + serializer.write_integer(members[0], self.int_enum1) if self.int_enum2 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum2"], self.int_enum2 - ) + serializer.write_integer(members[1], self.int_enum2) if self.int_enum3 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum3"], self.int_enum3 - ) + serializer.write_integer(members[2], self.int_enum3) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.int_enum_list) if self.int_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumSet"], - self.int_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.int_enum_set) if self.int_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumMap"], - self.int_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.int_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3295,61 +2966,48 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum1"] - ) - ) + kwargs["int_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["int_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum2"] - ) - ) + kwargs["int_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["int_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum3"] - ) - ) + kwargs["int_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumList"] + de, members[3] ) case 4: kwargs["int_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumSet"] + de, members[4] ) case 5: kwargs["int_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_INT_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_INT_ENUMS = APIOperation( input=XmlIntEnumsInput, output=XmlIntEnumsOutput, - schema=_SCHEMA_XML_INT_ENUMS, - input_schema=_SCHEMA_XML_INT_ENUMS_INPUT, - output_schema=_SCHEMA_XML_INT_ENUMS_OUTPUT, + static_schema=_SCHEMA_XML_INT_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3358,7 +3016,7 @@ class XmlListsInput: """Dataclass for XmlListsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3370,13 +3028,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_LISTS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3424,110 +3083,61 @@ class XmlListsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_LISTS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_LISTS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_LISTS_OPERATION_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithNamespace" - ], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3536,109 +3146,84 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_LISTS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["nestedStringList"], + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "renamedListMembers" - ], + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_LISTS_OPERATION_OUTPUT.members["structureList"] + de, members[13] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_LISTS_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_LISTS = APIOperation( input=XmlListsInput, output=XmlListsOperationOutput, - schema=_SCHEMA_XML_LISTS, - input_schema=_SCHEMA_XML_LISTS_INPUT, - output_schema=_SCHEMA_XML_LISTS_OPERATION_OUTPUT, + static_schema=_SCHEMA_XML_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3647,7 +3232,7 @@ class XmlNamespacesInput: """Dataclass for XmlNamespacesInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3659,20 +3244,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACES_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_xml_namespaced_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -3682,7 +3268,7 @@ def _deserialize_xml_namespaced_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3704,18 +3290,15 @@ class XmlNamespaceNested: values: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACE_NESTED, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACE_NESTED), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACE_NESTED).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_NAMESPACE_NESTED.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.values is not None: - _serialize_xml_namespaced_list( - serializer, _SCHEMA_XML_NAMESPACE_NESTED.members["values"], self.values - ) + _serialize_xml_namespaced_list(serializer, members[1], self.values) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3724,23 +3307,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACE_NESTED) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_NAMESPACE_NESTED.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["values"] = _deserialize_xml_namespaced_list( - de, _SCHEMA_XML_NAMESPACE_NESTED.members["values"] - ) + kwargs["values"] = _deserialize_xml_namespaced_list(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACE_NESTED, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3761,13 +3342,12 @@ class XmlNamespacesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_XML_NAMESPACES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3776,28 +3356,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = XmlNamespaceNested.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_NAMESPACES = APIOperation( input=XmlNamespacesInput, output=XmlNamespacesOutput, - schema=_SCHEMA_XML_NAMESPACES, - input_schema=_SCHEMA_XML_NAMESPACES_INPUT, - output_schema=_SCHEMA_XML_NAMESPACES_OUTPUT, + static_schema=_SCHEMA_XML_NAMESPACES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3806,7 +3385,7 @@ class XmlTimestampsInput: """Dataclass for XmlTimestampsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_TIMESTAMPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3818,13 +3397,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_TIMESTAMPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3857,47 +3437,30 @@ class XmlTimestampsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_TIMESTAMPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT).members_by_index if self.normal is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["normal"], self.normal - ) + serializer.write_timestamp(members[0], self.normal) if self.date_time is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTime"], self.date_time - ) + serializer.write_timestamp(members[1], self.date_time) if self.date_time_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"], - self.date_time_on_target, - ) + serializer.write_timestamp(members[2], self.date_time_on_target) if self.epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSeconds"], - self.epoch_seconds, - ) + serializer.write_timestamp(members[3], self.epoch_seconds) if self.epoch_seconds_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"], - self.epoch_seconds_on_target, - ) + serializer.write_timestamp(members[4], self.epoch_seconds_on_target) if self.http_date is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDate"], self.http_date - ) + serializer.write_timestamp(members[5], self.http_date) if self.http_date_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"], - self.http_date_on_target, - ) + serializer.write_timestamp(members[6], self.http_date_on_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3906,60 +3469,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["normal"] - ) + kwargs["normal"] = de.read_timestamp(members[0]) case 1: - kwargs["date_time"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTime"] - ) + kwargs["date_time"] = de.read_timestamp(members[1]) case 2: - kwargs["date_time_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"] - ) + kwargs["date_time_on_target"] = de.read_timestamp(members[2]) case 3: - kwargs["epoch_seconds"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSeconds"] - ) + kwargs["epoch_seconds"] = de.read_timestamp(members[3]) case 4: - kwargs["epoch_seconds_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"] - ) + kwargs["epoch_seconds_on_target"] = de.read_timestamp(members[4]) case 5: - kwargs["http_date"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDate"] - ) + kwargs["http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["http_date_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"] - ) + kwargs["http_date_on_target"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_TIMESTAMPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_TIMESTAMPS = APIOperation( input=XmlTimestampsInput, output=XmlTimestampsOutput, - schema=_SCHEMA_XML_TIMESTAMPS, - input_schema=_SCHEMA_XML_TIMESTAMPS_INPUT, - output_schema=_SCHEMA_XML_TIMESTAMPS_OUTPUT, + static_schema=_SCHEMA_XML_TIMESTAMPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3974,23 +3522,18 @@ class StructArg: recursive_arg: "StructArg | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCT_ARG, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCT_ARG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCT_ARG).members_by_index if self.string_arg is not None: - serializer.write_string( - _SCHEMA_STRUCT_ARG.members["StringArg"], self.string_arg - ) + serializer.write_string(members[0], self.string_arg) if self.other_arg is not None: - serializer.write_boolean( - _SCHEMA_STRUCT_ARG.members["OtherArg"], self.other_arg - ) + serializer.write_boolean(members[1], self.other_arg) if self.recursive_arg is not None: - serializer.write_struct( - _SCHEMA_STRUCT_ARG.members["RecursiveArg"], self.recursive_arg - ) + serializer.write_struct(members[2], self.recursive_arg) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3999,26 +3542,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCT_ARG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_arg"] = de.read_string( - _SCHEMA_STRUCT_ARG.members["StringArg"] - ) + kwargs["string_arg"] = de.read_string(members[0]) case 1: - kwargs["other_arg"] = de.read_boolean( - _SCHEMA_STRUCT_ARG.members["OtherArg"] - ) + kwargs["other_arg"] = de.read_boolean(members[1]) case 2: kwargs["recursive_arg"] = StructArg.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCT_ARG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4029,13 +3570,12 @@ class NestedStructuresInput: nested: "StructArg | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_STRUCTURES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_STRUCTURES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_STRUCTURES_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_NESTED_STRUCTURES_INPUT.members["Nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4044,16 +3584,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_STRUCTURES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = StructArg.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_STRUCTURES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4066,19 +3608,17 @@ class RecursiveXmlShapesOutputNested1: nested: "RecursiveXmlShapesOutputNested2 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["nested"], - self.nested, - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4087,23 +3627,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: kwargs["nested"] = RecursiveXmlShapesOutputNested2.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4116,19 +3654,17 @@ class RecursiveXmlShapesOutputNested2: recursive_member: "RecursiveXmlShapesOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2).members_by_index if self.bar is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2.members["bar"], self.bar - ) + serializer.write_string(members[0], self.bar) if self.recursive_member is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2.members["recursiveMember"], - self.recursive_member, - ) + serializer.write_struct(members[1], self.recursive_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4137,13 +3673,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bar"] = de.read_string( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2.members["bar"] - ) + kwargs["bar"] = de.read_string(members[0]) case 1: kwargs["recursive_member"] = ( @@ -4151,23 +3687,18 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NESTED_STRUCTURES = APIOperation( input=NestedStructuresInput, output=NestedStructuresOutput, - schema=_SCHEMA_NESTED_STRUCTURES, - input_schema=_SCHEMA_NESTED_STRUCTURES_INPUT, - output_schema=_SCHEMA_NESTED_STRUCTURES_OUTPUT, + static_schema=_SCHEMA_NESTED_STRUCTURES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4188,13 +3719,12 @@ class RecursiveXmlShapesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4203,28 +3733,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveXmlShapesOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RECURSIVE_XML_SHAPES = APIOperation( input=RecursiveXmlShapesInput, output=RecursiveXmlShapesOutput, - schema=_SCHEMA_RECURSIVE_XML_SHAPES, - input_schema=_SCHEMA_RECURSIVE_XML_SHAPES_INPUT, - output_schema=_SCHEMA_RECURSIVE_XML_SHAPES_OUTPUT, + static_schema=_SCHEMA_RECURSIVE_XML_SHAPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) diff --git a/codegen-output/rest-json-1/pyproject.toml b/codegen-output/rest-json-1/pyproject.toml index 953379f29..b852d3243 100644 --- a/codegen-output/rest-json-1/pyproject.toml +++ b/codegen-output/rest-json-1/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rest-json-1/src/restjson/_private/schemas.py b/codegen-output/rest-json-1/src/restjson/_private/schemas.py index ebfc1ecbe..07b9e8fe4 100644 --- a/codegen-output/rest-json-1/src/restjson/_private/schemas.py +++ b/codegen-output/rest-json-1/src/restjson/_private/schemas.py @@ -2,6123 +2,4267 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - BYTE, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -BOOLEAN_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#BooleanList"), - shape_type=ShapeType.LIST, - members={"member": {"target": BOOLEAN}}, -) - -DOUBLE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#DoubleList"), - shape_type=ShapeType.LIST, - members={"member": {"target": DOUBLE}}, -) - -FOO_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, -) -FOO_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) - -INTEGER_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, -) - -INTEGER_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) - -INTEGER_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) - -INTEGER_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) - -STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -STRING_LIST_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringListMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING_LIST}}, -) - -STRING_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -TIMESTAMP_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#TimestampList"), - shape_type=ShapeType.LIST, - members={"member": {"target": TIMESTAMP}}, -) - -ALL_QUERY_STRING_TYPES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#AllQueryStringTypesInput"), - members={ - "queryString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="String")], - }, - "queryStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="StringList") - ], - }, - "queryStringSet": { - "target": STRING_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="StringSet") - ], - }, - "queryByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Byte")], - }, - "queryShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Short")], - }, - "queryInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Integer")], - }, - "queryIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerList") - ], - }, - "queryIntegerSet": { - "target": INTEGER_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerSet") - ], - }, - "queryLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Long")], - }, - "queryFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Float")], - }, - "queryDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Double")], - }, - "queryDoubleList": { - "target": DOUBLE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="DoubleList") - ], - }, - "queryBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Boolean")], - }, - "queryBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="BooleanList") - ], - }, - "queryTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Timestamp") - ], - }, - "queryTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="TimestampList") - ], - }, - "queryEnum": { - "target": FOO_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Enum")], - }, - "queryEnumList": { - "target": FOO_ENUM_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="EnumList")], - }, - "queryIntegerEnum": { - "target": INTEGER_ENUM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerEnum") - ], - }, - "queryIntegerEnumList": { - "target": INTEGER_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerEnumList") - ], - }, - "queryParamsMapOfStringList": { - "target": STRING_LIST_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - }, - }, +n0 = "aws.protocoltests.shared" +_BL = "BooleanList" +_m = "member" +_DL = "DoubleList" +_FE = "FooEnum" +_FOO = "FOO" +_BAZ = "BAZ" +_BAR = "BAR" +_ONE = "ONE" +_ZERO = "ZERO" +_FEL = "FooEnumList" +_IE = "IntegerEnum" +_A = "A" +_B = "B" +_C = "C" +_IEL = "IntegerEnumList" +_IL = "IntegerList" +_IS = "IntegerSet" +_SL = "StringList" +_SLM = "StringListMap" +_k = "key" +_v = "value" +_SS = "StringSet" +_TL = "TimestampList" +n1 = "aws.protocoltests.restjson" +_AQSTI = "AllQueryStringTypesInput" +_qS = "queryString" +_sQ = "smithy.api#httpQuery" +_S = "String" +_qSL = "queryStringList" +_qSS = "queryStringSet" +_qB = "queryByte" +_By = "Byte" +_qSu = "queryShort" +_Sh = "Short" +_qI = "queryInteger" +_I = "Integer" +_qIL = "queryIntegerList" +_qIS = "queryIntegerSet" +_qL = "queryLong" +_L = "Long" +_qF = "queryFloat" +_F = "Float" +_qD = "queryDouble" +_D = "Double" +_qDL = "queryDoubleList" +_qBu = "queryBoolean" +_Bo = "Boolean" +_qBL = "queryBooleanList" +_qT = "queryTimestamp" +_T = "Timestamp" +_qTL = "queryTimestampList" +_qE = "queryEnum" +_E = "Enum" +_qEL = "queryEnumList" +_EL = "EnumList" +_qIE = "queryIntegerEnum" +_qIEL = "queryIntegerEnumList" +_qPMOSL = "queryParamsMapOfStringList" +_sQP = "smithy.api#httpQueryParams" +_AQSTO = "AllQueryStringTypesOutput" +_sSI = "smithy.synthetic#originalShapeId" +_sU = "smithy.api#Unit" +_AQST = "AllQueryStringTypes" +_s = "smithy.api#http" +_BPE = "BlobPayloadEvent" +_p = "payload" +_sP = "smithy.api#eventPayload" +_COD = "ClientOptionalDefaults" +_sm = "smithy.api#default" +_CNED = "ComplexNestedErrorData" +_Fo = "Foo" +_sN = "smithy.api#jsonName" +_Foo = "Fooooo" +_CE = "ComplexError" +_smi = "smithy.api#error" +_c = "client" +_sE = "smithy.api#httpError" +_H = "Header" +_sH = "smithy.api#httpHeader" +_XH = "X-Header" +_TLo = "TopLevel" +_N = "Nested" +_CAVQSI = "ConstantAndVariableQueryStringInput" +_b = "baz" +_mS = "maybeSet" +_CAVQSO = "ConstantAndVariableQueryStringOutput" +_CAVQS = "ConstantAndVariableQueryString" +_CQSI = "ConstantQueryStringInput" +_h = "hello" +_smit = "smithy.api#required" +_sL = "smithy.api#httpLabel" +_CQSO = "ConstantQueryStringOutput" +_CQS = "ConstantQueryString" +_CTPI = "ContentTypeParametersInput" +_CTPO = "ContentTypeParametersOutput" +_CTP = "ContentTypeParameters" +_DOI = "DatetimeOffsetsInput" +_DT = "DateTime" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_DOO = "DatetimeOffsetsOutput" +_d = "datetime" +_DO = "DatetimeOffsets" +_Do = "Document" +_TE = "TestEnum" +_TIE = "TestIntEnum" +_TWO = "TWO" +_TSL = "TestStringList" +_TSM = "TestStringMap" +_De = "Defaults" +_dS = "defaultString" +_hi = "hi" +_dB = "defaultBoolean" +_dL = "defaultList" +_dDM = "defaultDocumentMap" +_dDS = "defaultDocumentString" +_dDB = "defaultDocumentBoolean" +_dDL = "defaultDocumentList" +_dND = "defaultNullDocument" +_dT = "defaultTimestamp" +_dBe = "defaultBlob" +_YWJ = "YWJj" +_dBef = "defaultByte" +_dSe = "defaultShort" +_dI = "defaultInteger" +_dLe = "defaultLong" +_dF = "defaultFloat" +_dD = "defaultDouble" +_dM = "defaultMap" +_dE = "defaultEnum" +_dIE = "defaultIntEnum" +_eS = "emptyString" +_v_ = "" +_fB = "falseBoolean" +_eB = "emptyBlob" +_zB = "zeroByte" +_zS = "zeroShort" +_zI = "zeroInteger" +_zL = "zeroLong" +_zF = "zeroFloat" +_zD = "zeroDouble" +_DBM = "DenseBooleanMap" +_DNM = "DenseNumberMap" +_DSM = "DenseSetMap" +_DSMe = "DenseStringMap" +_GS = "GreetingStruct" +_DSMen = "DenseStructMap" +_Fa = "Farewell" +_ph = "phrase" +_by = "bye" +_Di = "Dialog" +_l = "language" +_g = "greeting" +_f = "farewell" +_DLi = "DialogList" +_DM = "DialogMap" +_DTI = "DocumentTypeInput" +_aDTIO = "aws.protocoltests.restjson#DocumentTypeInputOutput" +_sV = "stringValue" +_dV = "documentValue" +_DTO = "DocumentTypeOutput" +_DTo = "DocumentType" +_DVM = "DocumentValuedMap" +_DTAMVI = "DocumentTypeAsMapValueInput" +_aDTAMVIO = "aws.protocoltests.restjson#DocumentTypeAsMapValueInputOutput" +_dVM = "docValuedMap" +_DTAMVO = "DocumentTypeAsMapValueOutput" +_DTAMV = "DocumentTypeAsMapValue" +_DTAPI = "DocumentTypeAsPayloadInput" +_aDTAPIO = "aws.protocoltests.restjson#DocumentTypeAsPayloadInputOutput" +_sPm = "smithy.api#httpPayload" +_DTAPO = "DocumentTypeAsPayloadOutput" +_DTAP = "DocumentTypeAsPayload" +_EE = "ErrorEvent" +_me = "message" +_HE = "HeadersEvent" +_bH = "booleanHeader" +_sHm = "smithy.api#eventHeader" +_bHy = "byteHeader" +_sHh = "shortHeader" +_iH = "intHeader" +_lH = "longHeader" +_bHl = "blobHeader" +_sHt = "stringHeader" +_tH = "timestampHeader" +_PS = "PayloadStructure" +_sM = "structureMember" +_HAEPE = "HeadersAndExplicitPayloadEvent" +_he = "header" +_HAIPE = "HeadersAndImplicitPayloadEvent" +_SPE = "StringPayloadEvent" +_SPEt = "StructurePayloadEvent" +_PU = "PayloadUnion" +_uM = "unionMember" +_UPE = "UnionPayloadEvent" +_ES = "EventStream" +_smith = "smithy.api#streaming" +_hea = "headers" +_bP = "blobPayload" +_sPt = "stringPayload" +_sPtr = "structurePayload" +_uP = "unionPayload" +_hAEP = "headersAndExplicitPayload" +_hAIP = "headersAndImplicitPayload" +_e = "error" +_DSI = "DuplexStreamInput" +_st = "stream" +_DSO = "DuplexStreamOutput" +_DS = "DuplexStream" +_DSWDSI = "DuplexStreamWithDistinctStreamsInput" +_SE = "SingletonEvent" +_SES = "SingletonEventStream" +_si = "singleton" +_DSWDSO = "DuplexStreamWithDistinctStreamsOutput" +_DSWDS = "DuplexStreamWithDistinctStreams" +_DSWIMI = "DuplexStreamWithInitialMessagesInput" +_iRM = "initialRequestMember" +_irm = "initial-request-member" +_DSWIMO = "DuplexStreamWithInitialMessagesOutput" +_iRMn = "initialResponseMember" +_irm_ = "initial-response-member" +_SUE = "ServiceUnavailableError" +_se = "server" +_DSWIM = "DuplexStreamWithInitialMessages" +_EIAEOI = "EmptyInputAndEmptyOutputInput" +_EIAEOO = "EmptyInputAndEmptyOutputOutput" +_EIAEO = "EmptyInputAndEmptyOutput" +_EOI = "EndpointOperationInput" +_EOO = "EndpointOperationOutput" +_EO = "EndpointOperation" +_smithy = "smithy.api#endpoint" +_EWHLOI = "EndpointWithHostLabelOperationInput" +_aHLI = "aws.protocoltests.restjson#HostLabelInput" +_la = "label" +_sLm = "smithy.api#hostLabel" +_EWHLOO = "EndpointWithHostLabelOperationOutput" +_EWHLO = "EndpointWithHostLabelOperation" +_FSB = "FiniteStreamingBlob" +_sLmi = "smithy.api#requiresLength" +_FEo = "FooError" +_FSI = "FractionalSecondsInput" +_FSO = "FractionalSecondsOutput" +_FS = "FractionalSeconds" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_XG = "X-Greeting" +_IG = "InvalidGreeting" +_M = "Message" +_GWE = "GreetingWithErrors" +_HWPOI = "HostWithPathOperationInput" +_HWPOO = "HostWithPathOperationOutput" +_HWPO = "HostWithPathOperation" +_HCRI = "HttpChecksumRequiredInput" +_aHCRIO = "aws.protocoltests.restjson#HttpChecksumRequiredInputOutput" +_fo = "foo" +_HCRO = "HttpChecksumRequiredOutput" +_HCR = "HttpChecksumRequired" +_sCR = "smithy.api#httpChecksumRequired" +_SM = "StringMap" +_HEPHI = "HttpEmptyPrefixHeadersInput" +_pH = "prefixHeaders" +_sPH = "smithy.api#httpPrefixHeaders" +_sHp = "specificHeader" +_HEPHO = "HttpEmptyPrefixHeadersOutput" +_HEPH = "HttpEmptyPrefixHeaders" +_SEt = "StringEnum" +_V = "V" +_HEPI = "HttpEnumPayloadInput" +_aEPI = "aws.protocoltests.restjson#EnumPayloadInput" +_HEPO = "HttpEnumPayloadOutput" +_HEP = "HttpEnumPayload" +_HPTI = "HttpPayloadTraitsInput" +_aHPTIO = "aws.protocoltests.restjson#HttpPayloadTraitsInputOutput" +_XF = "X-Foo" +_bl = "blob" +_HPTO = "HttpPayloadTraitsOutput" +_HPT = "HttpPayloadTraits" +_TPB = "TextPlainBlob" +_sT = "smithy.api#mediaType" +_t = "text/plain" +_HPTWMTI = "HttpPayloadTraitsWithMediaTypeInput" +_aHPTWMTIO = "aws.protocoltests.restjson#HttpPayloadTraitsWithMediaTypeInputOutput" +_HPTWMTO = "HttpPayloadTraitsWithMediaTypeOutput" +_HPTWMT = "HttpPayloadTraitsWithMediaType" +_NP = "NestedPayload" +_n = "name" +_HPWSI = "HttpPayloadWithStructureInput" +_aHPWSIO = "aws.protocoltests.restjson#HttpPayloadWithStructureInputOutput" +_ne = "nested" +_HPWSO = "HttpPayloadWithStructureOutput" +_HPWS = "HttpPayloadWithStructure" +_UP = "UnionPayload" +_HPWUI = "HttpPayloadWithUnionInput" +_aHPWUIO = "aws.protocoltests.restjson#HttpPayloadWithUnionInputOutput" +_HPWUO = "HttpPayloadWithUnionOutput" +_HPWU = "HttpPayloadWithUnion" +_HPHI = "HttpPrefixHeadersInput" +_xf = "x-foo" +_fM = "fooMap" +_xf_ = "x-foo-" +_HPHO = "HttpPrefixHeadersOutput" +_HPH = "HttpPrefixHeaders" +_HPHIRI = "HttpPrefixHeadersInResponseInput" +_HPHIRO = "HttpPrefixHeadersInResponseOutput" +_HPHIR = "HttpPrefixHeadersInResponse" +_QM = "QueryMap" +_HQPOOI = "HttpQueryParamsOnlyOperationInput" +_aHQPOI = "aws.protocoltests.restjson#HttpQueryParamsOnlyInput" +_qM = "queryMap" +_HQPOOO = "HttpQueryParamsOnlyOperationOutput" +_HQPOO = "HttpQueryParamsOnlyOperation" +_HRWFLI = "HttpRequestWithFloatLabelsInput" +_fl = "float" +_do = "double" +_HRWFLO = "HttpRequestWithFloatLabelsOutput" +_HRWFL = "HttpRequestWithFloatLabels" +_HRWGLIPI = "HttpRequestWithGreedyLabelInPathInput" +_HRWGLIPO = "HttpRequestWithGreedyLabelInPathOutput" +_HRWGLIP = "HttpRequestWithGreedyLabelInPath" +_HRWLI = "HttpRequestWithLabelsInput" +_str = "string" +_sh = "short" +_i = "integer" +_lo = "long" +_bo = "boolean" +_ti = "timestamp" +_HRWLO = "HttpRequestWithLabelsOutput" +_HRWL = "HttpRequestWithLabels" +_ESp = "EpochSeconds" +_es = "epoch-seconds" +_HD = "HttpDate" +_hd = "http-date" +_HRWLATFI = "HttpRequestWithLabelsAndTimestampFormatInput" +_mES = "memberEpochSeconds" +_mHD = "memberHttpDate" +_mDT = "memberDateTime" +_dFe = "defaultFormat" +_tES = "targetEpochSeconds" +_tHD = "targetHttpDate" +_tDT = "targetDateTime" +_HRWLATFO = "HttpRequestWithLabelsAndTimestampFormatOutput" +_HRWLATF = "HttpRequestWithLabelsAndTimestampFormat" +_HRWRLI = "HttpRequestWithRegexLiteralInput" +_str_ = "str" +_HRWRLO = "HttpRequestWithRegexLiteralOutput" +_HRWRL = "HttpRequestWithRegexLiteral" +_HRCI = "HttpResponseCodeInput" +_HRCO = "HttpResponseCodeOutput" +_St = "Status" +_sRC = "smithy.api#httpResponseCode" +_HRC = "HttpResponseCode" +_HSPI = "HttpStringPayloadInput" +_aSPI = "aws.protocoltests.restjson#StringPayloadInput" +_HSPO = "HttpStringPayloadOutput" +_HSP = "HttpStringPayload" +_IQPIRI = "IgnoreQueryParamsInResponseInput" +_IQPIRO = "IgnoreQueryParamsInResponseOutput" +_IQPIR = "IgnoreQueryParamsInResponse" +_IAOWHI = "InputAndOutputWithHeadersInput" +_aIAOWHIO = "aws.protocoltests.restjson#InputAndOutputWithHeadersIO" +_hS = "headerString" +_XS = "X-String" +_hB = "headerByte" +_XB = "X-Byte" +_hSe = "headerShort" +_XS_ = "X-Short" +_hI = "headerInteger" +_XI = "X-Integer" +_hL = "headerLong" +_XL = "X-Long" +_hF = "headerFloat" +_XF_ = "X-Float" +_hD = "headerDouble" +_XD = "X-Double" +_hTB = "headerTrueBool" +_XB_ = "X-Boolean1" +_hFB = "headerFalseBool" +_XB__ = "X-Boolean2" +_hSL = "headerStringList" +_XS__ = "X-StringList" +_hSS = "headerStringSet" +_XS___ = "X-StringSet" +_hIL = "headerIntegerList" +_XI_ = "X-IntegerList" +_hBL = "headerBooleanList" +_XB___ = "X-BooleanList" +_hTL = "headerTimestampList" +_XT = "X-TimestampList" +_hE = "headerEnum" +_XE = "X-Enum" +_hEL = "headerEnumList" +_XE_ = "X-EnumList" +_hIE = "headerIntegerEnum" +_XI__ = "X-IntegerEnum" +_hIEL = "headerIntegerEnumList" +_XI___ = "X-IntegerEnumList" +_IAOWHO = "InputAndOutputWithHeadersOutput" +_IAOWH = "InputAndOutputWithHeaders" +_ISI = "InputStreamInput" +_ISO = "InputStreamOutput" +_ISn = "InputStream" +_ISWIRI = "InputStreamWithInitialRequestInput" +_ISWIRO = "InputStreamWithInitialRequestOutput" +_ISWIR = "InputStreamWithInitialRequest" +_JBI = "JsonBlobsInput" +_aJBIO = "aws.protocoltests.restjson#JsonBlobsInputOutput" +_da = "data" +_JBO = "JsonBlobsOutput" +_JB = "JsonBlobs" +_FEM = "FooEnumMap" +_FES = "FooEnumSet" +_JEI = "JsonEnumsInput" +_aJEIO = "aws.protocoltests.restjson#JsonEnumsInputOutput" +_fE = "fooEnum1" +_fEo = "fooEnum2" +_fEoo = "fooEnum3" +_fEL = "fooEnumList" +_fES = "fooEnumSet" +_fEM = "fooEnumMap" +_JEO = "JsonEnumsOutput" +_JE = "JsonEnums" +_JHS = "JsonHeaderString" +_a = "application/json" +_IEM = "IntegerEnumMap" +_IES = "IntegerEnumSet" +_JIEI = "JsonIntEnumsInput" +_aJIEIO = "aws.protocoltests.restjson#JsonIntEnumsInputOutput" +_iE = "integerEnum1" +_iEn = "integerEnum2" +_iEnt = "integerEnum3" +_iEL = "integerEnumList" +_iES = "integerEnumSet" +_iEM = "integerEnumMap" +_JIEO = "JsonIntEnumsOutput" +_JIE = "JsonIntEnums" +_NSL = "NestedStringList" +_SLMt = "StructureListMember" +_a_ = "a" +_b_ = "b" +_o = "other" +_SLt = "StructureList" +_JLI = "JsonListsInput" +_aJLIO = "aws.protocoltests.restjson#JsonListsInputOutput" +_sLt = "stringList" +_sS = "stringSet" +_iL = "integerList" +_bL = "booleanList" +_tL = "timestampList" +_eL = "enumList" +_iELn = "intEnumList" +_nSL = "nestedStringList" +_sLtr = "structureList" +_mSL = "myStructureList" +_JLO = "JsonListsOutput" +_JL = "JsonLists" +_JMI = "JsonMapsInput" +_aJMIO = "aws.protocoltests.restjson#JsonMapsInputOutput" +_dSM = "denseStructMap" +_dNM = "denseNumberMap" +_dBM = "denseBooleanMap" +_dSMe = "denseStringMap" +_dSMen = "denseSetMap" +_JMO = "JsonMapsOutput" +_JM = "JsonMaps" +_JTI = "JsonTimestampsInput" +_aJTIO = "aws.protocoltests.restjson#JsonTimestampsInputOutput" +_no = "normal" +_dTa = "dateTime" +_dTOT = "dateTimeOnTarget" +_eSp = "epochSeconds" +_eSOT = "epochSecondsOnTarget" +_hDt = "httpDate" +_hDOT = "httpDateOnTarget" +_JTO = "JsonTimestampsOutput" +_JT = "JsonTimestamps" +n2 = "aws.protocoltests.restjson.nested" +_sa = "salutation" +_NU = "NestedUnion" +_MU = "MyUnion" +_bV = "booleanValue" +_nV = "numberValue" +_bVl = "blobValue" +_tV = "timestampValue" +_eV = "enumValue" +_lV = "listValue" +_mV = "mapValue" +_sVt = "structureValue" +_rSV = "renamedStructureValue" +_uV = "unionValue" +_JUI = "JsonUnionsInput" +_aUIO = "aws.protocoltests.restjson#UnionInputOutput" +_co = "contents" +_JUO = "JsonUnionsOutput" +_JU = "JsonUnions" +_JV = "JsonValue" +_MAWBI = "MalformedAcceptWithBodyInput" +_MAWBO = "MalformedAcceptWithBodyOutput" +_aGS = "aws.protocoltests.shared#GreetingStruct" +_MAWB = "MalformedAcceptWithBody" +_MAWGSI = "MalformedAcceptWithGenericStringInput" +_MAWGSO = "MalformedAcceptWithGenericStringOutput" +_MAWGS = "MalformedAcceptWithGenericString" +_MAWPI = "MalformedAcceptWithPayloadInput" +_JBp = "JpegBlob" +_im = "image/jpeg" +_MAWPO = "MalformedAcceptWithPayloadOutput" +_MAWP = "MalformedAcceptWithPayload" +_MBI = "MalformedBlobInput" +_MBO = "MalformedBlobOutput" +_MB = "MalformedBlob" +_MBIa = "MalformedBooleanInput" +_bIB = "booleanInBody" +_bIP = "booleanInPath" +_bIQ = "booleanInQuery" +_bIH = "booleanInHeader" +_MBOa = "MalformedBooleanOutput" +_MBa = "MalformedBoolean" +_MBIal = "MalformedByteInput" +_bIBy = "byteInBody" +_bIPy = "byteInPath" +_bIQy = "byteInQuery" +_bIHy = "byteInHeader" +_MBOal = "MalformedByteOutput" +_MBal = "MalformedByte" +_MCTWBI = "MalformedContentTypeWithBodyInput" +_MCTWBO = "MalformedContentTypeWithBodyOutput" +_MCTWB = "MalformedContentTypeWithBody" +_MCTWGSI = "MalformedContentTypeWithGenericStringInput" +_MCTWGSO = "MalformedContentTypeWithGenericStringOutput" +_MCTWGS = "MalformedContentTypeWithGenericString" +_MCTWBIa = "MalformedContentTypeWithoutBodyInput" +_MCTWBOa = "MalformedContentTypeWithoutBodyOutput" +_MCTWBa = "MalformedContentTypeWithoutBody" +_MCTWBEII = "MalformedContentTypeWithoutBodyEmptyInputInput" +_MCTWBEIO = "MalformedContentTypeWithoutBodyEmptyInputOutput" +_MCTWBEI = "MalformedContentTypeWithoutBodyEmptyInput" +_MCTWPI = "MalformedContentTypeWithPayloadInput" +_MCTWPO = "MalformedContentTypeWithPayloadOutput" +_MCTWP = "MalformedContentTypeWithPayload" +_MDI = "MalformedDoubleInput" +_dIB = "doubleInBody" +_dIP = "doubleInPath" +_dIQ = "doubleInQuery" +_dIH = "doubleInHeader" +_MDO = "MalformedDoubleOutput" +_MD = "MalformedDouble" +_MFI = "MalformedFloatInput" +_fIB = "floatInBody" +_fIP = "floatInPath" +_fIQ = "floatInQuery" +_fIH = "floatInHeader" +_MFO = "MalformedFloatOutput" +_MF = "MalformedFloat" +_MII = "MalformedIntegerInput" +_iIB = "integerInBody" +_iIP = "integerInPath" +_iIQ = "integerInQuery" +_iIH = "integerInHeader" +_MIO = "MalformedIntegerOutput" +_MI = "MalformedInteger" +_SLi = "SimpleList" +_MLI = "MalformedListInput" +_bLo = "bodyList" +_MLO = "MalformedListOutput" +_ML = "MalformedList" +_MLIa = "MalformedLongInput" +_lIB = "longInBody" +_lIP = "longInPath" +_lIQ = "longInQuery" +_lIH = "longInHeader" +_MLOa = "MalformedLongOutput" +_MLa = "MalformedLong" +_SMi = "SimpleMap" +_MMI = "MalformedMapInput" +_bM = "bodyMap" +_MMO = "MalformedMapOutput" +_MM = "MalformedMap" +_MRBI = "MalformedRequestBodyInput" +_in = "int" +_MRBO = "MalformedRequestBodyOutput" +_MRB = "MalformedRequestBody" +_MSI = "MalformedShortInput" +_sIB = "shortInBody" +_sIP = "shortInPath" +_sIQ = "shortInQuery" +_sIH = "shortInHeader" +_MSO = "MalformedShortOutput" +_MS = "MalformedShort" +_MSIa = "MalformedStringInput" +_amth = "amz-media-typed-header" +_MSOa = "MalformedStringOutput" +_MSa = "MalformedString" +_MTBDTI = "MalformedTimestampBodyDateTimeInput" +_MTBDTO = "MalformedTimestampBodyDateTimeOutput" +_MTBDT = "MalformedTimestampBodyDateTime" +_MTBDI = "MalformedTimestampBodyDefaultInput" +_MTBDO = "MalformedTimestampBodyDefaultOutput" +_MTBD = "MalformedTimestampBodyDefault" +_MTBHDI = "MalformedTimestampBodyHttpDateInput" +_MTBHDO = "MalformedTimestampBodyHttpDateOutput" +_MTBHD = "MalformedTimestampBodyHttpDate" +_MTHDTI = "MalformedTimestampHeaderDateTimeInput" +_MTHDTO = "MalformedTimestampHeaderDateTimeOutput" +_MTHDT = "MalformedTimestampHeaderDateTime" +_MTHDI = "MalformedTimestampHeaderDefaultInput" +_MTHDO = "MalformedTimestampHeaderDefaultOutput" +_MTHD = "MalformedTimestampHeaderDefault" +_MTHEI = "MalformedTimestampHeaderEpochInput" +_MTHEO = "MalformedTimestampHeaderEpochOutput" +_MTHE = "MalformedTimestampHeaderEpoch" +_MTPDI = "MalformedTimestampPathDefaultInput" +_MTPDO = "MalformedTimestampPathDefaultOutput" +_MTPD = "MalformedTimestampPathDefault" +_MTPEI = "MalformedTimestampPathEpochInput" +_MTPEO = "MalformedTimestampPathEpochOutput" +_MTPE = "MalformedTimestampPathEpoch" +_MTPHDI = "MalformedTimestampPathHttpDateInput" +_MTPHDO = "MalformedTimestampPathHttpDateOutput" +_MTPHD = "MalformedTimestampPathHttpDate" +_MTQDI = "MalformedTimestampQueryDefaultInput" +_MTQDO = "MalformedTimestampQueryDefaultOutput" +_MTQD = "MalformedTimestampQueryDefault" +_MTQEI = "MalformedTimestampQueryEpochInput" +_MTQEO = "MalformedTimestampQueryEpochOutput" +_MTQE = "MalformedTimestampQueryEpoch" +_MTQHDI = "MalformedTimestampQueryHttpDateInput" +_MTQHDO = "MalformedTimestampQueryHttpDateOutput" +_MTQHD = "MalformedTimestampQueryHttpDate" +_SU = "SimpleUnion" +_MUI = "MalformedUnionInput" +_u = "union" +_MUO = "MalformedUnionOutput" +_MUa = "MalformedUnion" +_MTHI = "MediaTypeHeaderInput" +_j = "json" +_XJ = "X-Json" +_MTHO = "MediaTypeHeaderOutput" +_MTH = "MediaTypeHeader" +_NIANOI = "NoInputAndNoOutputInput" +_NIANOO = "NoInputAndNoOutputOutput" +_NIANO = "NoInputAndNoOutput" +_NIAOI = "NoInputAndOutputInput" +_NIAOO = "NoInputAndOutputOutput" +_NIAO = "NoInputAndOutput" +_NAEHCI = "NullAndEmptyHeadersClientInput" +_aNAEHIO = "aws.protocoltests.restjson#NullAndEmptyHeadersIO" +_XA = "X-A" +_XB____ = "X-B" +_c_ = "c" +_XC = "X-C" +_NAEHCO = "NullAndEmptyHeadersClientOutput" +_NAEHC = "NullAndEmptyHeadersClient" +_NAEHSI = "NullAndEmptyHeadersServerInput" +_NAEHSO = "NullAndEmptyHeadersServerOutput" +_NAEHS = "NullAndEmptyHeadersServer" +_ONSESI = "OmitsNullSerializesEmptyStringInput" +_nVu = "nullValue" +_Nu = "Null" +_Em = "Empty" +_ONSESO = "OmitsNullSerializesEmptyStringOutput" +_ONSES = "OmitsNullSerializesEmptyString" +_OSELI = "OmitsSerializingEmptyListsInput" +_OSELO = "OmitsSerializingEmptyListsOutput" +_OSEL = "OmitsSerializingEmptyLists" +_OWDI = "OperationWithDefaultsInput" +_de = "defaults" +_cOD = "clientOptionalDefaults" +_tLD = "topLevelDefault" +_oTLD = "otherTopLevelDefault" +_OWDO = "OperationWithDefaultsOutput" +_OWD = "OperationWithDefaults" +_di = "dialog" +_dLi = "dialogList" +_dMi = "dialogMap" +_OWNSI = "OperationWithNestedStructureInput" +_tLo = "topLevel" +_OWNSO = "OperationWithNestedStructureOutput" +_OWNS = "OperationWithNestedStructure" +_OSI = "OutputStreamInput" +_OSO = "OutputStreamOutput" +_OS = "OutputStream" +_OSWIRI = "OutputStreamWithInitialResponseInput" +_OSWIRO = "OutputStreamWithInitialResponseOutput" +_OSWIR = "OutputStreamWithInitialResponse" +_PC = "PayloadConfig" +_PA = "PlayerAction" +_q = "quit" +_PPAI = "PostPlayerActionInput" +_ac = "action" +_PPAO = "PostPlayerActionOutput" +_PPA = "PostPlayerAction" +_UWJN = "UnionWithJsonName" +_ba = "bar" +_baz = "_baz" +_PUWJNI = "PostUnionWithJsonNameInput" +_PUWJNO = "PostUnionWithJsonNameOutput" +_PUWJN = "PostUnionWithJsonName" +_PWCEI = "PutWithContentEncodingInput" +_en = "encoding" +_CE_ = "Content-Encoding" +_PWCEO = "PutWithContentEncodingOutput" +_PWCE = "PutWithContentEncoding" +_sC = "smithy.api#requestCompression" +_QITAFI = "QueryIdempotencyTokenAutoFillInput" +_to = "token" +_sTm = "smithy.api#idempotencyToken" +_QITAFO = "QueryIdempotencyTokenAutoFillOutput" +_QITAF = "QueryIdempotencyTokenAutoFill" +_QPASLMI = "QueryParamsAsStringListMapInput" +_qu = "qux" +_cor = "corge" +_QPASLMO = "QueryParamsAsStringListMapOutput" +_QPASLM = "QueryParamsAsStringListMap" +_QPI = "QueryPrecedenceInput" +_QPO = "QueryPrecedenceOutput" +_QP = "QueryPrecedence" +_RCHFI = "ResponseCodeHttpFallbackInput" +_aRCHFIO = "aws.protocoltests.restjson#ResponseCodeHttpFallbackInputOutput" +_RCHFO = "ResponseCodeHttpFallbackOutput" +_RCHF = "ResponseCodeHttpFallback" +_RCRI = "ResponseCodeRequiredInput" +_RCRO = "ResponseCodeRequiredOutput" +_rC = "responseCode" +_RCR = "ResponseCodeRequired" +_SSPI = "SimpleScalarPropertiesInput" +_aSSPIO = "aws.protocoltests.restjson#SimpleScalarPropertiesInputOutput" +_tBV = "trueBooleanValue" +_fBV = "falseBooleanValue" +_bVy = "byteValue" +_sVh = "shortValue" +_iV = "integerValue" +_lVo = "longValue" +_fV = "floatValue" +_dVo = "doubleValue" +_DD = "DoubleDribble" +_SSPO = "SimpleScalarPropertiesOutput" +_SSP = "SimpleScalarProperties" +_SSL = "SparseShortList" +_smithya = "smithy.api#sparse" +_SSLp = "SparseStringList" +_SJLI = "SparseJsonListsInput" +_aSJLIO = "aws.protocoltests.restjson#SparseJsonListsInputOutput" +_sSL = "sparseStringList" +_sSLp = "sparseShortList" +_SJLO = "SparseJsonListsOutput" +_SJL = "SparseJsonLists" +_SBM = "SparseBooleanMap" +_SNM = "SparseNumberMap" +_SSM = "SparseSetMap" +_SSMp = "SparseStringMap" +_SSMpa = "SparseStructMap" +_SJMI = "SparseJsonMapsInput" +_aSJMIO = "aws.protocoltests.restjson#SparseJsonMapsInputOutput" +_sSM = "sparseStructMap" +_sNM = "sparseNumberMap" +_sBM = "sparseBooleanMap" +_sSMp = "sparseStringMap" +_sSMpa = "sparseSetMap" +_SJMO = "SparseJsonMapsOutput" +_SJM = "SparseJsonMaps" +_SB = "StreamingBlob" +_STI = "StreamingTraitsInput" +_aSTIO = "aws.protocoltests.restjson#StreamingTraitsInputOutput" +_STO = "StreamingTraitsOutput" +_ST = "StreamingTraits" +_STRLI = "StreamingTraitsRequireLengthInput" +_STRLO = "StreamingTraitsRequireLengthOutput" +_STRL = "StreamingTraitsRequireLength" +_STPB = "StreamingTextPlainBlob" +_STWMTI = "StreamingTraitsWithMediaTypeInput" +_aSTWMTIO = "aws.protocoltests.restjson#StreamingTraitsWithMediaTypeInputOutput" +_STWMTO = "StreamingTraitsWithMediaTypeOutput" +_STWMT = "StreamingTraitsWithMediaType" +_TC = "TestConfig" +_tim = "timeout" +_TBSI = "TestBodyStructureInput" +_aTBSIO = "aws.protocoltests.restjson#TestBodyStructureInputOutput" +_tI = "testId" +_xati = "x-amz-test-id" +_tC = "testConfig" +_TBSO = "TestBodyStructureOutput" +_TBS = "TestBodyStructure" +_TGNINPI = "TestGetNoInputNoPayloadInput" +_TGNINPO = "TestGetNoInputNoPayloadOutput" +_aTNPIO = "aws.protocoltests.restjson#TestNoPayloadInputOutput" +_XATI = "X-Amz-Test-Id" +_TGNINP = "TestGetNoInputNoPayload" +_TGNPI = "TestGetNoPayloadInput" +_TGNPO = "TestGetNoPayloadOutput" +_TGNP = "TestGetNoPayload" +_TPBI = "TestPayloadBlobInput" +_aTPBIO = "aws.protocoltests.restjson#TestPayloadBlobInputOutput" +_cT = "contentType" +_CT = "Content-Type" +_TPBO = "TestPayloadBlobOutput" +_TPBe = "TestPayloadBlob" +_TPSI = "TestPayloadStructureInput" +_aTPSIO = "aws.protocoltests.restjson#TestPayloadStructureInputOutput" +_pC = "payloadConfig" +_TPSO = "TestPayloadStructureOutput" +_TPS = "TestPayloadStructure" +_TPNINPI = "TestPostNoInputNoPayloadInput" +_TPNINPO = "TestPostNoInputNoPayloadOutput" +_TPNINP = "TestPostNoInputNoPayload" +_TPNPI = "TestPostNoPayloadInput" +_TPNPO = "TestPostNoPayloadOutput" +_TPNP = "TestPostNoPayload" +_TFHI = "TimestampFormatHeadersInput" +_aTFHIO = "aws.protocoltests.restjson#TimestampFormatHeadersIO" +_Xm = "X-memberEpochSeconds" +_Xm_ = "X-memberHttpDate" +_Xm__ = "X-memberDateTime" +_Xd = "X-defaultFormat" +_Xt = "X-targetEpochSeconds" +_Xt_ = "X-targetHttpDate" +_Xt__ = "X-targetDateTime" +_TFHO = "TimestampFormatHeadersOutput" +_TFH = "TimestampFormatHeaders" +_UIAOI = "UnitInputAndOutputInput" +_UIAOO = "UnitInputAndOutputOutput" +_UIAO = "UnitInputAndOutput" +_RSION = "RecursiveShapesInputOutputNested1" +_RSIONe = "RecursiveShapesInputOutputNested2" +_rM = "recursiveMember" +_RSI = "RecursiveShapesInput" +_aRSIO = "aws.protocoltests.restjson#RecursiveShapesInputOutput" +_RSO = "RecursiveShapesOutput" +_RS = "RecursiveShapes" +_RJ = "RestJson" +_aw = "aws.auth#sigv4" +_sB = "smithy.rules#endpointBdd" +_aws = "aws.api#service" +_aJ = "aws.protocols#restJson1" + +BOOLEAN_LIST = (16, n0, _BL, 0, (_m,), ((2, 0),)) + +DOUBLE_LIST = (16, n0, _DL, 0, (_m,), ((10, 0),)) + +FOO_ENUM = ( + 14, + n0, + _FE, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +FOO_ENUM_LIST = (16, n0, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) + +INTEGER_ENUM = (15, n0, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) + +INTEGER_ENUM_LIST = (16, n0, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) + +INTEGER_LIST = (16, n0, _IL, 0, (_m,), ((7, 0),)) + +INTEGER_SET = (16, n0, _IS, 0, (_m,), ((7, 0),)) + +STRING_LIST = (16, n0, _SL, 0, (_m,), ((3, 0),)) + +STRING_LIST_MAP = (17, n0, _SLM, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) + +STRING_SET = (16, n0, _SS, 0, (_m,), ((3, 0),)) + +TIMESTAMP_LIST = (16, n0, _TL, 0, (_m,), ((4, 0),)) + +ALL_QUERY_STRING_TYPES_INPUT = ( + 18, + n1, + _AQSTI, + 0, + ( + _qS, + _qSL, + _qSS, + _qB, + _qSu, + _qI, + _qIL, + _qIS, + _qL, + _qF, + _qD, + _qDL, + _qBu, + _qBL, + _qT, + _qTL, + _qE, + _qEL, + _qIE, + _qIEL, + _qPMOSL, + ), + ( + (3, {_sQ: _S}), + (STRING_LIST, {_sQ: _SL}), + (STRING_SET, {_sQ: _SS}), + (5, {_sQ: _By}), + (6, {_sQ: _Sh}), + (7, {_sQ: _I}), + (INTEGER_LIST, {_sQ: _IL}), + (INTEGER_SET, {_sQ: _IS}), + (8, {_sQ: _L}), + (9, {_sQ: _F}), + (10, {_sQ: _D}), + (DOUBLE_LIST, {_sQ: _DL}), + (2, {_sQ: _Bo}), + (BOOLEAN_LIST, {_sQ: _BL}), + (4, {_sQ: _T}), + (TIMESTAMP_LIST, {_sQ: _TL}), + (FOO_ENUM, {_sQ: _E}), + (FOO_ENUM_LIST, {_sQ: _EL}), + (INTEGER_ENUM, {_sQ: _IE}), + (INTEGER_ENUM_LIST, {_sQ: _IEL}), + (STRING_LIST_MAP, 1024), + ), ) -ALL_QUERY_STRING_TYPES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#AllQueryStringTypesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ALL_QUERY_STRING_TYPES = Schema( - id=ShapeID("aws.protocoltests.restjson#AllQueryStringTypes"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/AllQueryStringTypesInput", "method": "GET"} - ), - ) - ], -) +ALL_QUERY_STRING_TYPES_OUTPUT = (18, n1, _AQSTO, {_sSI: _sU}) -BLOB_PAYLOAD_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#BlobPayloadEvent"), - members={ - "payload": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#eventPayload"))], - } - }, +ALL_QUERY_STRING_TYPES = ( + 23, + n1, + _AQST, + {_s: MappingProxyType({"uri": "/AllQueryStringTypesInput", "method": "GET"})}, + ALL_QUERY_STRING_TYPES_INPUT, + ALL_QUERY_STRING_TYPES_OUTPUT, + (), ) -CLIENT_OPTIONAL_DEFAULTS = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ClientOptionalDefaults"), - members={ - "member": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - } - }, -) +BLOB_PAYLOAD_EVENT = (18, n1, _BPE, 0, (_p,), ((1, {_sP: None}),)) -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ComplexNestedErrorData"), - members={ - "Foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="Fooooo")], - } - }, -) +CLIENT_OPTIONAL_DEFAULTS = (18, n1, _COD, 0, (_m,), ((7, {_sm: 0}),)) -COMPLEX_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ComplexError"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=403), - ], - members={ - "Header": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Header") - ], - }, - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, +COMPLEX_NESTED_ERROR_DATA = (18, n1, _CNED, 0, (_Fo,), ((3, {_sN: _Foo}),)) + +COMPLEX_ERROR = ( + 18, + n1, + _CE, + {_smi: _c, _sE: 403}, + (_H, _TLo, _N), + ((3, {_sH: _XH}), (3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ConstantAndVariableQueryStringInput"), - members={ - "baz": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="baz")], - }, - "maybeSet": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="maybeSet")], - }, - }, +CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT = ( + 18, + n1, + _CAVQSI, + 0, + (_b, _mS), + ((3, {_sQ: _b}), (3, {_sQ: _mS})), ) -CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ConstantAndVariableQueryStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -CONSTANT_AND_VARIABLE_QUERY_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#ConstantAndVariableQueryString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/ConstantAndVariableQueryString?foo=bar", "method": "GET"} - ), +CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT = (18, n1, _CAVQSO, {_sSI: _sU}) + +CONSTANT_AND_VARIABLE_QUERY_STRING = ( + 23, + n1, + _CAVQS, + { + _s: MappingProxyType( + {"uri": "/ConstantAndVariableQueryString?foo=bar", "method": "GET"} ) - ], -) - -CONSTANT_QUERY_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ConstantQueryStringInput"), - members={ - "hello": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } }, + CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, + CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, + (), ) -CONSTANT_QUERY_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ConstantQueryStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -CONSTANT_QUERY_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#ConstantQueryString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/ConstantQueryString/{hello}?foo=bar&hello", "method": "GET"} - ), +CONSTANT_QUERY_STRING_INPUT = (18, n1, _CQSI, 0, (_h,), ((3, 9),)) + +CONSTANT_QUERY_STRING_OUTPUT = (18, n1, _CQSO, {_sSI: _sU}) + +CONSTANT_QUERY_STRING = ( + 23, + n1, + _CQS, + { + _s: MappingProxyType( + {"uri": "/ConstantQueryString/{hello}?foo=bar&hello", "method": "GET"} ) - ], + }, + CONSTANT_QUERY_STRING_INPUT, + CONSTANT_QUERY_STRING_OUTPUT, + (), ) -CONTENT_TYPE_PARAMETERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ContentTypeParametersInput"), - members={"value": {"target": INTEGER}}, -) +CONTENT_TYPE_PARAMETERS_INPUT = (18, n1, _CTPI, 0, (_v,), ((7, 0),)) -CONTENT_TYPE_PARAMETERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ContentTypeParametersOutput") -) +CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n1, _CTPO, 0) -CONTENT_TYPE_PARAMETERS = Schema( - id=ShapeID("aws.protocoltests.restjson#ContentTypeParameters"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/ContentTypeParameters", "method": "POST"}), - ) - ], +CONTENT_TYPE_PARAMETERS = ( + 23, + n1, + _CTP, + {_s: MappingProxyType({"uri": "/ContentTypeParameters", "method": "POST"})}, + CONTENT_TYPE_PARAMETERS_INPUT, + CONTENT_TYPE_PARAMETERS_OUTPUT, + (), ) -DATETIME_OFFSETS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DatetimeOffsetsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +DATETIME_OFFSETS_INPUT = (18, n1, _DOI, {_sSI: _sU}) -DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.shared#DateTime"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], -) +DATE_TIME = (4, n0, _DT, {_sF: _dt}) -DATETIME_OFFSETS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DatetimeOffsetsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) +DATETIME_OFFSETS_OUTPUT = (18, n1, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -DATETIME_OFFSETS = Schema( - id=ShapeID("aws.protocoltests.restjson#DatetimeOffsets"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/DatetimeOffsets", "method": "POST"}), - ) - ], -) - -DOCUMENT = Schema( - id=ShapeID("aws.protocoltests.restjson#Document"), shape_type=ShapeType.DOCUMENT -) - -TEST_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestEnum"), - shape_type=ShapeType.ENUM, - members={"FOO": {"target": UNIT}, "BAR": {"target": UNIT}, "BAZ": {"target": UNIT}}, -) - -TEST_INT_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestIntEnum"), - shape_type=ShapeType.INT_ENUM, - members={"ONE": {"target": UNIT}, "TWO": {"target": UNIT}}, -) - -TEST_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -TEST_STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestStringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -DEFAULTS = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#Defaults"), - members={ - "defaultString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultList": { - "target": TEST_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultDocumentMap": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultDocumentString": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultDocumentBoolean": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultDocumentList": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultNullDocument": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=None)], - }, - "defaultTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "defaultBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="YWJj")], - }, - "defaultByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=10)], - }, - "defaultLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=100)], - }, - "defaultFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultMap": { - "target": TEST_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultEnum": { - "target": TEST_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="FOO")], - }, - "defaultIntEnum": { - "target": TEST_INT_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "falseBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=False)], - }, - "emptyBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "zeroByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - "zeroDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - }, +DATETIME_OFFSETS = ( + 23, + n1, + _DO, + {_s: MappingProxyType({"uri": "/DatetimeOffsets", "method": "POST"})}, + DATETIME_OFFSETS_INPUT, + DATETIME_OFFSETS_OUTPUT, + (), ) -DENSE_BOOLEAN_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DenseBooleanMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": BOOLEAN}}, -) +DOCUMENT = (13, n1, _Do, 0) -DENSE_NUMBER_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DenseNumberMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER}}, +TEST_ENUM = (14, n1, _TE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) + +TEST_INT_ENUM = (15, n1, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) + +TEST_STRING_LIST = (16, n1, _TSL, 0, (_m,), ((3, 0),)) + +TEST_STRING_MAP = (17, n1, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) + +DEFAULTS = ( + 18, + n1, + _De, + 0, + ( + _dS, + _dB, + _dL, + _dDM, + _dDS, + _dDB, + _dDL, + _dND, + _dT, + _dBe, + _dBef, + _dSe, + _dI, + _dLe, + _dF, + _dD, + _dM, + _dE, + _dIE, + _eS, + _fB, + _eB, + _zB, + _zS, + _zI, + _zL, + _zF, + _zD, + ), + ( + (3, {_sm: _hi}), + (2, {_sm: True}), + (TEST_STRING_LIST, {_sm: ()}), + (DOCUMENT, {_sm: None}), + (DOCUMENT, {_sm: _hi}), + (DOCUMENT, {_sm: True}), + (DOCUMENT, {_sm: ()}), + (DOCUMENT, {_sm: None}), + (4, {_sm: 0}), + (1, {_sm: _YWJ}), + (5, {_sm: 1}), + (6, {_sm: 1}), + (7, {_sm: 10}), + (8, {_sm: 100}), + (9, {_sm: 1.0}), + (10, {_sm: 1.0}), + (TEST_STRING_MAP, {_sm: None}), + (TEST_ENUM, {_sm: _FOO}), + (TEST_INT_ENUM, {_sm: 1}), + (3, {_sm: _v_}), + (2, {_sm: False}), + (1, {_sm: _v_}), + (5, {_sm: 0}), + (6, {_sm: 0}), + (7, {_sm: 0}), + (8, {_sm: 0}), + (9, {_sm: 0.0}), + (10, {_sm: 0.0}), + ), ) -DENSE_SET_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DenseSetMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING_SET}}, +DENSE_BOOLEAN_MAP = (17, n1, _DBM, 0, (_k, _v), ((3, 0), (2, 0))) + +DENSE_NUMBER_MAP = (17, n1, _DNM, 0, (_k, _v), ((3, 0), (7, 0))) + +DENSE_SET_MAP = (17, n1, _DSM, 0, (_k, _v), ((3, 0), (STRING_SET, 0))) + +DENSE_STRING_MAP = (17, n1, _DSMe, 0, (_k, _v), ((3, 0), (3, 0))) + +GREETING_STRUCT = (18, n0, _GS, 0, (_hi,), ((3, 0),)) + +DENSE_STRUCT_MAP = (17, n1, _DSMen, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) + +FAREWELL = (18, n1, _Fa, 0, (_ph,), ((3, {_sm: _by}),)) + +DIALOG = (18, n1, _Di, 0, (_l, _g, _f), ((3, 0), (3, {_sm: _hi}), (FAREWELL, 0))) + +DIALOG_LIST = (16, n1, _DLi, 0, (_m,), ((DIALOG, 0),)) + +DIALOG_MAP = (17, n1, _DM, 0, (_k, _v), ((3, 0), (DIALOG, 0))) + +DOCUMENT_TYPE_INPUT = ( + 18, + n1, + _DTI, + {_sSI: _aDTIO}, + (_sV, _dV), + ((3, 0), (DOCUMENT, 0)), ) -DENSE_STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DenseStringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, +DOCUMENT_TYPE_OUTPUT = ( + 18, + n1, + _DTO, + {_sSI: _aDTIO}, + (_sV, _dV), + ((3, 0), (DOCUMENT, 0)), ) -GREETING_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, +DOCUMENT_TYPE = ( + 23, + n1, + _DTo, + {_s: MappingProxyType({"uri": "/DocumentType", "method": "PUT"})}, + DOCUMENT_TYPE_INPUT, + DOCUMENT_TYPE_OUTPUT, + (), ) -DENSE_STRUCT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DenseStructMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, +DOCUMENT_VALUED_MAP = (17, n1, _DVM, 0, (_k, _v), ((3, 0), (DOCUMENT, 0))) + +DOCUMENT_TYPE_AS_MAP_VALUE_INPUT = ( + 18, + n1, + _DTAMVI, + {_sSI: _aDTAMVIO}, + (_dVM,), + ((DOCUMENT_VALUED_MAP, 0),), ) -FAREWELL = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#Farewell"), - members={ - "phrase": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="bye")], - } - }, +DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT = ( + 18, + n1, + _DTAMVO, + {_sSI: _aDTAMVIO}, + (_dVM,), + ((DOCUMENT_VALUED_MAP, 0),), ) -DIALOG = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#Dialog"), - members={ - "language": {"target": STRING}, - "greeting": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "farewell": {"target": FAREWELL}, - }, +DOCUMENT_TYPE_AS_MAP_VALUE = ( + 23, + n1, + _DTAMV, + {_s: MappingProxyType({"uri": "/DocumentTypeAsMapValue", "method": "PUT"})}, + DOCUMENT_TYPE_AS_MAP_VALUE_INPUT, + DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT, + (), ) -DIALOG_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DialogList"), - shape_type=ShapeType.LIST, - members={"member": {"target": DIALOG}}, +DOCUMENT_TYPE_AS_PAYLOAD_INPUT = ( + 18, + n1, + _DTAPI, + {_sSI: _aDTAPIO}, + (_dV,), + ((DOCUMENT, 16),), ) -DIALOG_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DialogMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": DIALOG}}, +DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT = ( + 18, + n1, + _DTAPO, + {_sSI: _aDTAPIO}, + (_dV,), + ((DOCUMENT, 16),), ) -DOCUMENT_TYPE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#DocumentTypeInputOutput", - ) - ], - members={"stringValue": {"target": STRING}, "documentValue": {"target": DOCUMENT}}, +DOCUMENT_TYPE_AS_PAYLOAD = ( + 23, + n1, + _DTAP, + {_s: MappingProxyType({"uri": "/DocumentTypeAsPayload", "method": "PUT"})}, + DOCUMENT_TYPE_AS_PAYLOAD_INPUT, + DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT, + (), +) + +ERROR_EVENT = (18, n1, _EE, {_smi: _c}, (_me,), ((3, 0),)) + +HEADERS_EVENT = ( + 18, + n1, + _HE, + 0, + (_bH, _bHy, _sHh, _iH, _lH, _bHl, _sHt, _tH), + ( + (2, {_sHm: None}), + (5, {_sHm: None}), + (6, {_sHm: None}), + (7, {_sHm: None}), + (8, {_sHm: None}), + (1, {_sHm: None}), + (3, {_sHm: None}), + (DATE_TIME, {_sHm: None}), + ), ) -DOCUMENT_TYPE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#DocumentTypeInputOutput", - ) - ], - members={"stringValue": {"target": STRING}, "documentValue": {"target": DOCUMENT}}, +PAYLOAD_STRUCTURE = (18, n1, _PS, 0, (_sM,), ((3, 0),)) + +HEADERS_AND_EXPLICIT_PAYLOAD_EVENT = ( + 18, + n1, + _HAEPE, + 0, + (_he, _p), + ((3, {_sHm: None}), (PAYLOAD_STRUCTURE, {_sP: None})), ) -DOCUMENT_TYPE = Schema( - id=ShapeID("aws.protocoltests.restjson#DocumentType"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/DocumentType", "method": "PUT"}), - ) - ], +HEADERS_AND_IMPLICIT_PAYLOAD_EVENT = ( + 18, + n1, + _HAIPE, + 0, + (_he, _p), + ((3, {_sHm: None}), (3, 0)), ) -DOCUMENT_VALUED_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentValuedMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": DOCUMENT}}, +STRING_PAYLOAD_EVENT = (18, n1, _SPE, 0, (_p,), ((3, {_sP: None}),)) + +STRUCTURE_PAYLOAD_EVENT = (18, n1, _SPEt, 0, (_p,), ((PAYLOAD_STRUCTURE, {_sP: None}),)) + +PAYLOAD_UNION = (19, n1, _PU, 0, (_uM,), ((3, 0),)) + +UNION_PAYLOAD_EVENT = (18, n1, _UPE, 0, (_p,), ((PAYLOAD_UNION, {_sP: None}),)) + +EVENT_STREAM = ( + 19, + n1, + _ES, + {_smith: None}, + (_hea, _bP, _sPt, _sPtr, _uP, _hAEP, _hAIP, _e), + ( + (HEADERS_EVENT, 0), + (BLOB_PAYLOAD_EVENT, 0), + (STRING_PAYLOAD_EVENT, 0), + (STRUCTURE_PAYLOAD_EVENT, 0), + (UNION_PAYLOAD_EVENT, 0), + (HEADERS_AND_EXPLICIT_PAYLOAD_EVENT, 0), + (HEADERS_AND_IMPLICIT_PAYLOAD_EVENT, 0), + (ERROR_EVENT, 0), + ), ) -DOCUMENT_TYPE_AS_MAP_VALUE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeAsMapValueInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#DocumentTypeAsMapValueInputOutput", - ) - ], - members={"docValuedMap": {"target": DOCUMENT_VALUED_MAP}}, +DUPLEX_STREAM_INPUT = (18, n1, _DSI, 0, (_st,), ((EVENT_STREAM, 16),)) + +DUPLEX_STREAM_OUTPUT = (18, n1, _DSO, 0, (_st,), ((EVENT_STREAM, 16),)) + +DUPLEX_STREAM = ( + 23, + n1, + _DS, + {_s: MappingProxyType({"method": "POST", "uri": "/DuplexStream"})}, + DUPLEX_STREAM_INPUT, + DUPLEX_STREAM_OUTPUT, + (), ) -DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeAsMapValueOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#DocumentTypeAsMapValueInputOutput", - ) - ], - members={"docValuedMap": {"target": DOCUMENT_VALUED_MAP}}, +DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT = ( + 18, + n1, + _DSWDSI, + 0, + (_st,), + ((EVENT_STREAM, 16),), ) -DOCUMENT_TYPE_AS_MAP_VALUE = Schema( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeAsMapValue"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/DocumentTypeAsMapValue", "method": "PUT"}), - ) - ], +SINGLETON_EVENT = (18, n1, _SE, 0, (_v,), ((3, 0),)) + +SINGLETON_EVENT_STREAM = (19, n1, _SES, 0, (_si,), ((SINGLETON_EVENT, 0),)) + +DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT = ( + 18, + n1, + _DSWDSO, + 0, + (_st,), + ((SINGLETON_EVENT_STREAM, 16),), ) -DOCUMENT_TYPE_AS_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeAsPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#DocumentTypeAsPayloadInputOutput", +DUPLEX_STREAM_WITH_DISTINCT_STREAMS = ( + 23, + n1, + _DSWDS, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/DuplexStreamWithDistinctStreams"} ) - ], - members={ - "documentValue": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } }, + DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT, + DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT, + (), ) -DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeAsPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#DocumentTypeAsPayloadInputOutput", - ) - ], - members={ - "documentValue": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT = ( + 18, + n1, + _DSWIMI, + 0, + (_iRM, _st), + ((3, {_sH: _irm, _smit: None}), (EVENT_STREAM, 16)), +) + +DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT = ( + 18, + n1, + _DSWIMO, + 0, + (_iRMn, _st), + ((3, {_sH: _irm_, _smit: None}), (EVENT_STREAM, 16)), ) -DOCUMENT_TYPE_AS_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#DocumentTypeAsPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/DocumentTypeAsPayload", "method": "PUT"}), +SERVICE_UNAVAILABLE_ERROR = (18, n1, _SUE, {_smi: _se, _sE: 500}, (_me,), ((3, 0),)) + +DUPLEX_STREAM_WITH_INITIAL_MESSAGES = ( + 23, + n1, + _DSWIM, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/DuplexStreamWithInitialMessages"} ) - ], -) - -ERROR_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ErrorEvent"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={"message": {"target": STRING}}, -) - -HEADERS_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HeadersEvent"), - members={ - "booleanHeader": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "byteHeader": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "shortHeader": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "intHeader": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "longHeader": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "blobHeader": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "stringHeader": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "timestampHeader": { - "target": DATE_TIME, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, }, + DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT, + DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT, + (SERVICE_UNAVAILABLE_ERROR,), ) -PAYLOAD_STRUCTURE = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PayloadStructure"), - members={"structureMember": {"target": STRING}}, +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n1, _EIAEOI, 0) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n1, _EIAEOO, 0) + +EMPTY_INPUT_AND_EMPTY_OUTPUT = ( + 23, + n1, + _EIAEO, + {_s: MappingProxyType({"uri": "/EmptyInputAndEmptyOutput", "method": "POST"})}, + EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, + EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + (), ) -HEADERS_AND_EXPLICIT_PAYLOAD_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HeadersAndExplicitPayloadEvent"), - members={ - "header": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "payload": { - "target": PAYLOAD_STRUCTURE, - "traits": [Trait.new(id=ShapeID("smithy.api#eventPayload"))], - }, +ENDPOINT_OPERATION_INPUT = (18, n1, _EOI, {_sSI: _sU}) + +ENDPOINT_OPERATION_OUTPUT = (18, n1, _EOO, {_sSI: _sU}) + +ENDPOINT_OPERATION = ( + 23, + n1, + _EO, + { + _smithy: MappingProxyType({"hostPrefix": "foo."}), + _s: MappingProxyType({"uri": "/EndpointOperation", "method": "POST"}), }, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), ) -HEADERS_AND_IMPLICIT_PAYLOAD_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HeadersAndImplicitPayloadEvent"), - members={ - "header": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#eventHeader"))], - }, - "payload": {"target": STRING}, - }, +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( + 18, + n1, + _EWHLOI, + {_sSI: _aHLI}, + (_la,), + ((3, 257),), ) -STRING_PAYLOAD_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StringPayloadEvent"), - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#eventPayload"))], - } +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n1, _EWHLOO, {_sSI: _sU}) + +ENDPOINT_WITH_HOST_LABEL_OPERATION = ( + 23, + n1, + _EWHLO, + { + _smithy: MappingProxyType({"hostPrefix": "foo.{label}."}), + _s: MappingProxyType( + {"uri": "/EndpointWithHostLabelOperation", "method": "POST"} + ), }, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), ) -STRUCTURE_PAYLOAD_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StructurePayloadEvent"), - members={ - "payload": { - "target": PAYLOAD_STRUCTURE, - "traits": [Trait.new(id=ShapeID("smithy.api#eventPayload"))], - } - }, +FINITE_STREAMING_BLOB = (1, n1, _FSB, {_smith: None, _sLmi: None}) + +FOO_ERROR = (18, n1, _FEo, {_smi: _se, _sE: 500}) + +FRACTIONAL_SECONDS_INPUT = (18, n1, _FSI, {_sSI: _sU}) + +FRACTIONAL_SECONDS_OUTPUT = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) + +FRACTIONAL_SECONDS = ( + 23, + n1, + _FS, + {_s: MappingProxyType({"uri": "/FractionalSeconds", "method": "POST"})}, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), ) -PAYLOAD_UNION = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PayloadUnion"), - shape_type=ShapeType.UNION, - members={"unionMember": {"target": STRING}}, +GREETING_WITH_ERRORS_INPUT = (18, n1, _GWEI, {_sSI: _sU}) + +GREETING_WITH_ERRORS_OUTPUT = (18, n1, _GWEO, 0, (_g,), ((3, {_sH: _XG}),)) + +INVALID_GREETING = (18, n1, _IG, {_smi: _c, _sE: 400}, (_M,), ((3, 0),)) + +GREETING_WITH_ERRORS = ( + 23, + n1, + _GWE, + {_s: MappingProxyType({"uri": "/GreetingWithErrors", "method": "PUT"})}, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR, FOO_ERROR), ) -UNION_PAYLOAD_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#UnionPayloadEvent"), - members={ - "payload": { - "target": PAYLOAD_UNION, - "traits": [Trait.new(id=ShapeID("smithy.api#eventPayload"))], - } - }, +HOST_WITH_PATH_OPERATION_INPUT = (18, n1, _HWPOI, {_sSI: _sU}) + +HOST_WITH_PATH_OPERATION_OUTPUT = (18, n1, _HWPOO, {_sSI: _sU}) + +HOST_WITH_PATH_OPERATION = ( + 23, + n1, + _HWPO, + {_s: MappingProxyType({"uri": "/HostWithPathOperation", "method": "GET"})}, + HOST_WITH_PATH_OPERATION_INPUT, + HOST_WITH_PATH_OPERATION_OUTPUT, + (), ) -EVENT_STREAM = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EventStream"), - shape_type=ShapeType.UNION, - traits=[Trait.new(id=ShapeID("smithy.api#streaming"))], - members={ - "headers": {"target": HEADERS_EVENT}, - "blobPayload": {"target": BLOB_PAYLOAD_EVENT}, - "stringPayload": {"target": STRING_PAYLOAD_EVENT}, - "structurePayload": {"target": STRUCTURE_PAYLOAD_EVENT}, - "unionPayload": {"target": UNION_PAYLOAD_EVENT}, - "headersAndExplicitPayload": {"target": HEADERS_AND_EXPLICIT_PAYLOAD_EVENT}, - "headersAndImplicitPayload": {"target": HEADERS_AND_IMPLICIT_PAYLOAD_EVENT}, - "error": {"target": ERROR_EVENT}, +HTTP_CHECKSUM_REQUIRED_INPUT = (18, n1, _HCRI, {_sSI: _aHCRIO}, (_fo,), ((3, 0),)) + +HTTP_CHECKSUM_REQUIRED_OUTPUT = (18, n1, _HCRO, {_sSI: _aHCRIO}, (_fo,), ((3, 0),)) + +HTTP_CHECKSUM_REQUIRED = ( + 23, + n1, + _HCR, + { + _s: MappingProxyType({"uri": "/HttpChecksumRequired", "method": "POST"}), + _sCR: None, }, + HTTP_CHECKSUM_REQUIRED_INPUT, + HTTP_CHECKSUM_REQUIRED_OUTPUT, + (), ) -DUPLEX_STREAM_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamInput"), - members={ - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +STRING_MAP = (17, n0, _SM, 0, (_k, _v), ((3, 0), (3, 0))) + +HTTP_EMPTY_PREFIX_HEADERS_INPUT = ( + 18, + n1, + _HEPHI, + 0, + (_pH, _sHp), + ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -DUPLEX_STREAM_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamOutput"), - members={ - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +HTTP_EMPTY_PREFIX_HEADERS_OUTPUT = ( + 18, + n1, + _HEPHO, + 0, + (_pH, _sHp), + ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -DUPLEX_STREAM = Schema( - id=ShapeID("aws.protocoltests.restjson#DuplexStream"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"method": "POST", "uri": "/DuplexStream"}), - ) - ], +HTTP_EMPTY_PREFIX_HEADERS = ( + 23, + n1, + _HEPH, + {_s: MappingProxyType({"uri": "/HttpEmptyPrefixHeaders", "method": "GET"})}, + HTTP_EMPTY_PREFIX_HEADERS_INPUT, + HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, + (), ) -DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamWithDistinctStreamsInput"), - members={ - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +STRING_ENUM = (14, n1, _SEt, 0, (_V,), ((-1, 0),)) + +HTTP_ENUM_PAYLOAD_INPUT = (18, n1, _HEPI, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) + +HTTP_ENUM_PAYLOAD_OUTPUT = (18, n1, _HEPO, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) + +HTTP_ENUM_PAYLOAD = ( + 23, + n1, + _HEP, + {_s: MappingProxyType({"uri": "/EnumPayload", "method": "POST"})}, + HTTP_ENUM_PAYLOAD_INPUT, + HTTP_ENUM_PAYLOAD_OUTPUT, + (), ) -SINGLETON_EVENT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SingletonEvent"), - members={"value": {"target": STRING}}, +HTTP_PAYLOAD_TRAITS_INPUT = ( + 18, + n1, + _HPTI, + {_sSI: _aHPTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (1, 16)), ) -SINGLETON_EVENT_STREAM = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SingletonEventStream"), - shape_type=ShapeType.UNION, - members={"singleton": {"target": SINGLETON_EVENT}}, +HTTP_PAYLOAD_TRAITS_OUTPUT = ( + 18, + n1, + _HPTO, + {_sSI: _aHPTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (1, 16)), ) -DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamWithDistinctStreamsOutput"), - members={ - "stream": { - "target": SINGLETON_EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +HTTP_PAYLOAD_TRAITS = ( + 23, + n1, + _HPT, + {_s: MappingProxyType({"uri": "/HttpPayloadTraits", "method": "POST"})}, + HTTP_PAYLOAD_TRAITS_INPUT, + HTTP_PAYLOAD_TRAITS_OUTPUT, + (), +) + +TEXT_PLAIN_BLOB = (1, n0, _TPB, {_sT: _t}) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT = ( + 18, + n1, + _HPTWMTI, + {_sSI: _aHPTWMTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), +) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT = ( + 18, + n1, + _HPTWMTO, + {_sSI: _aHPTWMTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), +) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = ( + 23, + n1, + _HPTWMT, + { + _s: MappingProxyType( + {"uri": "/HttpPayloadTraitsWithMediaType", "method": "POST"} + ) + }, + HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, + HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + (), +) + +NESTED_PAYLOAD = (18, n1, _NP, 0, (_g, _n), ((3, 0), (3, 0))) + +HTTP_PAYLOAD_WITH_STRUCTURE_INPUT = ( + 18, + n1, + _HPWSI, + {_sSI: _aHPWSIO}, + (_ne,), + ((NESTED_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT = ( + 18, + n1, + _HPWSO, + {_sSI: _aHPWSIO}, + (_ne,), + ((NESTED_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_STRUCTURE = ( + 23, + n1, + _HPWS, + {_s: MappingProxyType({"uri": "/HttpPayloadWithStructure", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, + HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, + (), +) + +UNION_PAYLOAD = (19, n1, _UP, 0, (_g,), ((3, 0),)) + +HTTP_PAYLOAD_WITH_UNION_INPUT = ( + 18, + n1, + _HPWUI, + {_sSI: _aHPWUIO}, + (_ne,), + ((UNION_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_UNION_OUTPUT = ( + 18, + n1, + _HPWUO, + {_sSI: _aHPWUIO}, + (_ne,), + ((UNION_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_UNION = ( + 23, + n1, + _HPWU, + {_s: MappingProxyType({"uri": "/HttpPayloadWithUnion", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_UNION_INPUT, + HTTP_PAYLOAD_WITH_UNION_OUTPUT, + (), +) + +HTTP_PREFIX_HEADERS_INPUT = ( + 18, + n1, + _HPHI, + 0, + (_fo, _fM), + ((3, {_sH: _xf}), (STRING_MAP, {_sPH: _xf_})), +) + +HTTP_PREFIX_HEADERS_OUTPUT = ( + 18, + n1, + _HPHO, + 0, + (_fo, _fM), + ((3, {_sH: _xf}), (STRING_MAP, {_sPH: _xf_})), +) + +HTTP_PREFIX_HEADERS = ( + 23, + n1, + _HPH, + {_s: MappingProxyType({"uri": "/HttpPrefixHeaders", "method": "GET"})}, + HTTP_PREFIX_HEADERS_INPUT, + HTTP_PREFIX_HEADERS_OUTPUT, + (), +) + +HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT = (18, n1, _HPHIRI, 0) + +HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT = ( + 18, + n1, + _HPHIRO, + 0, + (_pH,), + ((STRING_MAP, {_sPH: _v_}),), ) -DUPLEX_STREAM_WITH_DISTINCT_STREAMS = Schema( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamWithDistinctStreams"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/DuplexStreamWithDistinctStreams"} - ), - ) - ], +HTTP_PREFIX_HEADERS_IN_RESPONSE = ( + 23, + n1, + _HPHIR, + {_s: MappingProxyType({"uri": "/HttpPrefixHeadersResponse", "method": "GET"})}, + HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT, + HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT, + (), +) + +QUERY_MAP = (17, n1, _QM, 0, (_k, _v), ((3, 0), (3, 0))) + +HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT = ( + 18, + n1, + _HQPOOI, + {_sSI: _aHQPOI}, + (_qM,), + ((QUERY_MAP, 1024),), ) -DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamWithInitialMessagesInput"), - members={ - "initialRequestMember": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="initial-request-member" - ), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, +HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT = (18, n1, _HQPOOO, {_sSI: _sU}) + +HTTP_QUERY_PARAMS_ONLY_OPERATION = ( + 23, + n1, + _HQPOO, + {_s: MappingProxyType({"uri": "/http-query-params-only", "method": "GET"})}, + HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT, + HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT = ( + 18, + n1, + _HRWFLI, + 0, + (_fl, _do), + ((9, 9), (10, 9)), +) + +HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT = (18, n1, _HRWFLO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_FLOAT_LABELS = ( + 23, + n1, + _HRWFL, + { + _s: MappingProxyType( + {"method": "GET", "uri": "/FloatHttpLabels/{float}/{double}"} + ) + }, + HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, + HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT = ( + 18, + n1, + _HRWGLIPI, + 0, + (_fo, _b), + ((3, 9), (3, 9)), +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT = (18, n1, _HRWGLIPO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = ( + 23, + n1, + _HRWGLIP, + { + _s: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}", + } + ) + }, + HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, + HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_LABELS_INPUT = ( + 18, + n1, + _HRWLI, + 0, + (_str, _sh, _i, _lo, _fl, _do, _bo, _ti), + ((3, 9), (6, 9), (7, 9), (8, 9), (9, 9), (10, 9), (2, 9), (4, 9)), +) + +HTTP_REQUEST_WITH_LABELS_OUTPUT = (18, n1, _HRWLO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_LABELS = ( + 23, + n1, + _HRWL, + { + _s: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}", + } + ) }, + HTTP_REQUEST_WITH_LABELS_INPUT, + HTTP_REQUEST_WITH_LABELS_OUTPUT, + (), +) + +EPOCH_SECONDS = (4, n0, _ESp, {_sF: _es}) + +HTTP_DATE = (4, n0, _HD, {_sF: _hd}) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT = ( + 18, + n1, + _HRWLATFI, + 0, + (_mES, _mHD, _mDT, _dFe, _tES, _tHD, _tDT), + ( + (4, {_sF: _es, _smit: None, _sL: None}), + (4, {_sF: _hd, _smit: None, _sL: None}), + (4, {_sF: _dt, _smit: None, _sL: None}), + (4, 9), + (EPOCH_SECONDS, 9), + (HTTP_DATE, 9), + (DATE_TIME, 9), + ), ) -DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamWithInitialMessagesOutput"), - members={ - "initialResponseMember": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="initial-response-member" - ), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT = (18, n1, _HRWLATFO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = ( + 23, + n1, + _HRWLATF, + { + _s: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}", + } + ) + }, + HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, + HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT = (18, n1, _HRWRLI, 0, (_str_,), ((3, 9),)) + +HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT = (18, n1, _HRWRLO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_REGEX_LITERAL = ( + 23, + n1, + _HRWRL, + {_s: MappingProxyType({"method": "GET", "uri": "/ReDosLiteral/{str}/(a+)+"})}, + HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT, + HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT, + (), +) + +HTTP_RESPONSE_CODE_INPUT = (18, n1, _HRCI, {_sSI: _sU}) + +HTTP_RESPONSE_CODE_OUTPUT = (18, n1, _HRCO, 0, (_St,), ((7, 128),)) + +HTTP_RESPONSE_CODE = ( + 23, + n1, + _HRC, + {_s: MappingProxyType({"uri": "/HttpResponseCode", "method": "PUT"})}, + HTTP_RESPONSE_CODE_INPUT, + HTTP_RESPONSE_CODE_OUTPUT, + (), +) + +HTTP_STRING_PAYLOAD_INPUT = (18, n1, _HSPI, {_sSI: _aSPI}, (_p,), ((3, 16),)) + +HTTP_STRING_PAYLOAD_OUTPUT = (18, n1, _HSPO, {_sSI: _aSPI}, (_p,), ((3, 16),)) + +HTTP_STRING_PAYLOAD = ( + 23, + n1, + _HSP, + {_s: MappingProxyType({"uri": "/StringPayload", "method": "POST"})}, + HTTP_STRING_PAYLOAD_INPUT, + HTTP_STRING_PAYLOAD_OUTPUT, + (), +) + +IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT = (18, n1, _IQPIRI, {_sSI: _sU}) + +IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT = (18, n1, _IQPIRO, 0, (_b,), ((3, {_sQ: _b}),)) + +IGNORE_QUERY_PARAMS_IN_RESPONSE = ( + 23, + n1, + _IQPIR, + {_s: MappingProxyType({"uri": "/IgnoreQueryParamsInResponse", "method": "GET"})}, + IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, + IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, + (), +) + +INPUT_AND_OUTPUT_WITH_HEADERS_INPUT = ( + 18, + n1, + _IAOWHI, + {_sSI: _aIAOWHIO}, + ( + _hS, + _hB, + _hSe, + _hI, + _hL, + _hF, + _hD, + _hTB, + _hFB, + _hSL, + _hSS, + _hIL, + _hBL, + _hTL, + _hE, + _hEL, + _hIE, + _hIEL, + ), + ( + (3, {_sH: _XS}), + (5, {_sH: _XB}), + (6, {_sH: _XS_}), + (7, {_sH: _XI}), + (8, {_sH: _XL}), + (9, {_sH: _XF_}), + (10, {_sH: _XD}), + (2, {_sH: _XB_}), + (2, {_sH: _XB__}), + (STRING_LIST, {_sH: _XS__}), + (STRING_SET, {_sH: _XS___}), + (INTEGER_LIST, {_sH: _XI_}), + (BOOLEAN_LIST, {_sH: _XB___}), + (TIMESTAMP_LIST, {_sH: _XT}), + (FOO_ENUM, {_sH: _XE}), + (FOO_ENUM_LIST, {_sH: _XE_}), + (INTEGER_ENUM, {_sH: _XI__}), + (INTEGER_ENUM_LIST, {_sH: _XI___}), + ), ) -SERVICE_UNAVAILABLE_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ServiceUnavailableError"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="server"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=500), - ], - members={"message": {"target": STRING}}, -) - -DUPLEX_STREAM_WITH_INITIAL_MESSAGES = Schema( - id=ShapeID("aws.protocoltests.restjson#DuplexStreamWithInitialMessages"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/DuplexStreamWithInitialMessages"} - ), - ) - ], +INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT = ( + 18, + n1, + _IAOWHO, + {_sSI: _aIAOWHIO}, + ( + _hS, + _hB, + _hSe, + _hI, + _hL, + _hF, + _hD, + _hTB, + _hFB, + _hSL, + _hSS, + _hIL, + _hBL, + _hTL, + _hE, + _hEL, + _hIE, + _hIEL, + ), + ( + (3, {_sH: _XS}), + (5, {_sH: _XB}), + (6, {_sH: _XS_}), + (7, {_sH: _XI}), + (8, {_sH: _XL}), + (9, {_sH: _XF_}), + (10, {_sH: _XD}), + (2, {_sH: _XB_}), + (2, {_sH: _XB__}), + (STRING_LIST, {_sH: _XS__}), + (STRING_SET, {_sH: _XS___}), + (INTEGER_LIST, {_sH: _XI_}), + (BOOLEAN_LIST, {_sH: _XB___}), + (TIMESTAMP_LIST, {_sH: _XT}), + (FOO_ENUM, {_sH: _XE}), + (FOO_ENUM_LIST, {_sH: _XE_}), + (INTEGER_ENUM, {_sH: _XI__}), + (INTEGER_ENUM_LIST, {_sH: _XI___}), + ), ) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EmptyInputAndEmptyOutputInput") +INPUT_AND_OUTPUT_WITH_HEADERS = ( + 23, + n1, + _IAOWH, + {_s: MappingProxyType({"uri": "/InputAndOutputWithHeaders", "method": "POST"})}, + INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, + INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, + (), ) -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EmptyInputAndEmptyOutputOutput") +INPUT_STREAM_INPUT = (18, n1, _ISI, 0, (_st,), ((EVENT_STREAM, 16),)) + +INPUT_STREAM_OUTPUT = (18, n1, _ISO, {_sSI: _sU}) + +INPUT_STREAM = ( + 23, + n1, + _ISn, + {_s: MappingProxyType({"method": "POST", "uri": "/InputStream"})}, + INPUT_STREAM_INPUT, + INPUT_STREAM_OUTPUT, + (), ) -EMPTY_INPUT_AND_EMPTY_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restjson#EmptyInputAndEmptyOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/EmptyInputAndEmptyOutput", "method": "POST"} - ), - ) - ], +INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT = ( + 18, + n1, + _ISWIRI, + 0, + (_iRM, _st), + ((3, {_sH: _irm, _smit: None}), (EVENT_STREAM, 16)), ) -ENDPOINT_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EndpointOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT = (18, n1, _ISWIRO, {_sSI: _sU}) + +INPUT_STREAM_WITH_INITIAL_REQUEST = ( + 23, + n1, + _ISWIR, + {_s: MappingProxyType({"method": "POST", "uri": "/InputStreamWithInitialRequest"})}, + INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT, + INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT, + (), ) -ENDPOINT_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EndpointOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +JSON_BLOBS_INPUT = (18, n1, _JBI, {_sSI: _aJBIO}, (_da,), ((1, 0),)) + +JSON_BLOBS_OUTPUT = (18, n1, _JBO, {_sSI: _aJBIO}, (_da,), ((1, 0),)) + +JSON_BLOBS = ( + 23, + n1, + _JB, + {_s: MappingProxyType({"uri": "/JsonBlobs", "method": "POST"})}, + JSON_BLOBS_INPUT, + JSON_BLOBS_OUTPUT, + (), ) -ENDPOINT_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restjson#EndpointOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo."}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/EndpointOperation", "method": "POST"}), - ), - ], +FOO_ENUM_MAP = (17, n0, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) + +FOO_ENUM_SET = (16, n0, _FES, 0, (_m,), ((FOO_ENUM, 0),)) + +JSON_ENUMS_INPUT = ( + 18, + n1, + _JEI, + {_sSI: _aJEIO}, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EndpointWithHostLabelOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HostLabelInput", - ) - ], - members={ - "label": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, +JSON_ENUMS_OUTPUT = ( + 18, + n1, + _JEO, + {_sSI: _aJEIO}, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#EndpointWithHostLabelOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +JSON_ENUMS = ( + 23, + n1, + _JE, + {_s: MappingProxyType({"uri": "/JsonEnums", "method": "PUT"})}, + JSON_ENUMS_INPUT, + JSON_ENUMS_OUTPUT, + (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restjson#EndpointWithHostLabelOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo.{label}."}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/EndpointWithHostLabelOperation", "method": "POST"} - ), - ), - ], +JSON_HEADER_STRING = (3, n1, _JHS, {_sT: _a}) + +INTEGER_ENUM_MAP = (17, n0, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) + +INTEGER_ENUM_SET = (16, n0, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) + +JSON_INT_ENUMS_INPUT = ( + 18, + n1, + _JIEI, + {_sSI: _aJIEIO}, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), ) -FINITE_STREAMING_BLOB = Schema( - id=ShapeID("aws.protocoltests.restjson#FiniteStreamingBlob"), - shape_type=ShapeType.BLOB, - traits=[ - Trait.new(id=ShapeID("smithy.api#streaming")), - Trait.new(id=ShapeID("smithy.api#requiresLength")), - ], +JSON_INT_ENUMS_OUTPUT = ( + 18, + n1, + _JIEO, + {_sSI: _aJIEIO}, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), ) -FOO_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#FooError"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="server"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=500), - ], +JSON_INT_ENUMS = ( + 23, + n1, + _JIE, + {_s: MappingProxyType({"uri": "/JsonIntEnums", "method": "PUT"})}, + JSON_INT_ENUMS_INPUT, + JSON_INT_ENUMS_OUTPUT, + (), +) + +NESTED_STRING_LIST = (16, n0, _NSL, 0, (_m,), ((STRING_LIST, 0),)) + +STRUCTURE_LIST_MEMBER = (18, n1, _SLMt, 0, (_a_, _b_), ((3, {_sN: _v}), (3, {_sN: _o}))) + +STRUCTURE_LIST = (16, n1, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, 0),)) + +JSON_LISTS_INPUT = ( + 18, + n1, + _JLI, + {_sSI: _aJLIO}, + (_sLt, _sS, _iL, _bL, _tL, _eL, _iELn, _nSL, _sLtr), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (STRUCTURE_LIST, {_sN: _mSL}), + ), ) -FRACTIONAL_SECONDS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#FractionalSecondsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +JSON_LISTS_OUTPUT = ( + 18, + n1, + _JLO, + {_sSI: _aJLIO}, + (_sLt, _sS, _iL, _bL, _tL, _eL, _iELn, _nSL, _sLtr), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (STRUCTURE_LIST, {_sN: _mSL}), + ), ) -FRACTIONAL_SECONDS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#FractionalSecondsOutput"), - members={"datetime": {"target": DATE_TIME}}, +JSON_LISTS = ( + 23, + n1, + _JL, + {_s: MappingProxyType({"uri": "/JsonLists", "method": "PUT"})}, + JSON_LISTS_INPUT, + JSON_LISTS_OUTPUT, + (), +) + +JSON_MAPS_INPUT = ( + 18, + n1, + _JMI, + {_sSI: _aJMIO}, + (_dSM, _dNM, _dBM, _dSMe, _dSMen), + ( + (DENSE_STRUCT_MAP, 0), + (DENSE_NUMBER_MAP, 0), + (DENSE_BOOLEAN_MAP, 0), + (DENSE_STRING_MAP, 0), + (DENSE_SET_MAP, 0), + ), ) -FRACTIONAL_SECONDS = Schema( - id=ShapeID("aws.protocoltests.restjson#FractionalSeconds"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/FractionalSeconds", "method": "POST"}), - ) - ], +JSON_MAPS_OUTPUT = ( + 18, + n1, + _JMO, + {_sSI: _aJMIO}, + (_dSM, _dNM, _dBM, _dSMe, _dSMen), + ( + (DENSE_STRUCT_MAP, 0), + (DENSE_NUMBER_MAP, 0), + (DENSE_BOOLEAN_MAP, 0), + (DENSE_STRING_MAP, 0), + (DENSE_SET_MAP, 0), + ), ) -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#GreetingWithErrorsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#GreetingWithErrorsOutput"), - members={ - "greeting": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Greeting") - ], - } - }, +JSON_MAPS = ( + 23, + n1, + _JM, + {_s: MappingProxyType({"uri": "/JsonMaps", "method": "POST"})}, + JSON_MAPS_INPUT, + JSON_MAPS_OUTPUT, + (), +) + +JSON_TIMESTAMPS_INPUT = ( + 18, + n1, + _JTI, + {_sSI: _aJTIO}, + (_no, _dTa, _dTOT, _eSp, _eSOT, _hDt, _hDOT), + ( + (4, 0), + (4, {_sF: _dt}), + (DATE_TIME, 0), + (4, {_sF: _es}), + (EPOCH_SECONDS, 0), + (4, {_sF: _hd}), + (HTTP_DATE, 0), + ), ) -INVALID_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InvalidGreeting"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=400), - ], - members={"Message": {"target": STRING}}, +JSON_TIMESTAMPS_OUTPUT = ( + 18, + n1, + _JTO, + {_sSI: _aJTIO}, + (_no, _dTa, _dTOT, _eSp, _eSOT, _hDt, _hDOT), + ( + (4, 0), + (4, {_sF: _dt}), + (DATE_TIME, 0), + (4, {_sF: _es}), + (EPOCH_SECONDS, 0), + (4, {_sF: _hd}), + (HTTP_DATE, 0), + ), ) -GREETING_WITH_ERRORS = Schema( - id=ShapeID("aws.protocoltests.restjson#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/GreetingWithErrors", "method": "PUT"}), - ) - ], +JSON_TIMESTAMPS = ( + 23, + n1, + _JT, + {_s: MappingProxyType({"uri": "/JsonTimestamps", "method": "POST"})}, + JSON_TIMESTAMPS_INPUT, + JSON_TIMESTAMPS_OUTPUT, + (), +) + +RENAMED_GREETING = (18, n2, _GS, 0, (_sa,), ((3, 0),)) + +NESTED_UNION = (19, n1, _NU, 0, (_sV,), ((3, 0),)) + +MY_UNION = ( + 19, + n1, + _MU, + 0, + (_sV, _bV, _nV, _bVl, _tV, _eV, _lV, _mV, _sVt, _rSV, _uV), + ( + (3, 0), + (2, 0), + (7, 0), + (1, 0), + (4, 0), + (FOO_ENUM, 0), + (STRING_LIST, 0), + (STRING_MAP, 0), + (GREETING_STRUCT, 0), + (RENAMED_GREETING, 0), + (NESTED_UNION, 0), + ), ) -HOST_WITH_PATH_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HostWithPathOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +JSON_UNIONS_INPUT = (18, n1, _JUI, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) + +JSON_UNIONS_OUTPUT = (18, n1, _JUO, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) + +JSON_UNIONS = ( + 23, + n1, + _JU, + {_s: MappingProxyType({"uri": "/JsonUnions", "method": "PUT"})}, + JSON_UNIONS_INPUT, + JSON_UNIONS_OUTPUT, + (), ) -HOST_WITH_PATH_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HostWithPathOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +JSON_VALUE = (3, n1, _JV, {_sT: _a}) + +MALFORMED_ACCEPT_WITH_BODY_INPUT = (18, n1, _MAWBI, {_sSI: _sU}) + +MALFORMED_ACCEPT_WITH_BODY_OUTPUT = (18, n1, _MAWBO, {_sSI: _aGS}, (_hi,), ((3, 0),)) + +MALFORMED_ACCEPT_WITH_BODY = ( + 23, + n1, + _MAWB, + {_s: MappingProxyType({"method": "POST", "uri": "/MalformedAcceptWithBody"})}, + MALFORMED_ACCEPT_WITH_BODY_INPUT, + MALFORMED_ACCEPT_WITH_BODY_OUTPUT, + (), ) -HOST_WITH_PATH_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restjson#HostWithPathOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HostWithPathOperation", "method": "GET"}), +MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT = (18, n1, _MAWGSI, {_sSI: _sU}) + +MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT = (18, n1, _MAWGSO, 0, (_p,), ((3, 16),)) + +MALFORMED_ACCEPT_WITH_GENERIC_STRING = ( + 23, + n1, + _MAWGS, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/MalformedAcceptWithGenericString"} ) - ], + }, + MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT, + MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT, + (), ) -HTTP_CHECKSUM_REQUIRED_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpChecksumRequiredInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpChecksumRequiredInputOutput", - ) - ], - members={"foo": {"target": STRING}}, +MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT = (18, n1, _MAWPI, {_sSI: _sU}) + +JPEG_BLOB = (1, n0, _JBp, {_sT: _im}) + +MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT = (18, n1, _MAWPO, 0, (_p,), ((JPEG_BLOB, 16),)) + +MALFORMED_ACCEPT_WITH_PAYLOAD = ( + 23, + n1, + _MAWP, + {_s: MappingProxyType({"method": "POST", "uri": "/MalformedAcceptWithPayload"})}, + MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT, + MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT, + (), ) -HTTP_CHECKSUM_REQUIRED_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpChecksumRequiredOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpChecksumRequiredInputOutput", - ) - ], - members={"foo": {"target": STRING}}, +MALFORMED_BLOB_INPUT = (18, n1, _MBI, 0, (_bl,), ((1, 0),)) + +MALFORMED_BLOB_OUTPUT = (18, n1, _MBO, {_sSI: _sU}) + +MALFORMED_BLOB = ( + 23, + n1, + _MB, + {_s: MappingProxyType({"uri": "/MalformedBlob", "method": "POST"})}, + MALFORMED_BLOB_INPUT, + MALFORMED_BLOB_OUTPUT, + (), ) -HTTP_CHECKSUM_REQUIRED = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpChecksumRequired"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpChecksumRequired", "method": "POST"}), - ), - Trait.new(id=ShapeID("smithy.api#httpChecksumRequired")), - ], -) - -STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -HTTP_EMPTY_PREFIX_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpEmptyPrefixHeadersInput"), - members={ - "prefixHeaders": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="")], - }, - "specificHeader": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="hello")], - }, - }, +MALFORMED_BOOLEAN_INPUT = ( + 18, + n1, + _MBIa, + 0, + (_bIB, _bIP, _bIQ, _bIH), + ((2, 0), (2, 9), (2, {_sQ: _bIQ}), (2, {_sH: _bIH})), ) -HTTP_EMPTY_PREFIX_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpEmptyPrefixHeadersOutput"), - members={ - "prefixHeaders": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="")], - }, - "specificHeader": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="hello")], - }, +MALFORMED_BOOLEAN_OUTPUT = (18, n1, _MBOa, {_sSI: _sU}) + +MALFORMED_BOOLEAN = ( + 23, + n1, + _MBa, + { + _s: MappingProxyType( + {"uri": "/MalformedBoolean/{booleanInPath}", "method": "POST"} + ) }, + MALFORMED_BOOLEAN_INPUT, + MALFORMED_BOOLEAN_OUTPUT, + (), ) -HTTP_EMPTY_PREFIX_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpEmptyPrefixHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpEmptyPrefixHeaders", "method": "GET"}), - ) - ], +MALFORMED_BYTE_INPUT = ( + 18, + n1, + _MBIal, + 0, + (_bIBy, _bIPy, _bIQy, _bIHy), + ((5, 0), (5, 9), (5, {_sQ: _bIQy}), (5, {_sH: _bIHy})), ) -STRING_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StringEnum"), - shape_type=ShapeType.ENUM, - members={"V": {"target": UNIT}}, +MALFORMED_BYTE_OUTPUT = (18, n1, _MBOal, {_sSI: _sU}) + +MALFORMED_BYTE = ( + 23, + n1, + _MBal, + {_s: MappingProxyType({"uri": "/MalformedByte/{byteInPath}", "method": "POST"})}, + MALFORMED_BYTE_INPUT, + MALFORMED_BYTE_OUTPUT, + (), ) -HTTP_ENUM_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpEnumPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#EnumPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT = ( + 18, + n1, + _MCTWBI, + {_sSI: _aGS}, + (_hi,), + ((3, 0),), ) -HTTP_ENUM_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpEnumPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#EnumPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT = (18, n1, _MCTWBO, {_sSI: _sU}) + +MALFORMED_CONTENT_TYPE_WITH_BODY = ( + 23, + n1, + _MCTWB, + {_s: MappingProxyType({"method": "POST", "uri": "/MalformedContentTypeWithBody"})}, + MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT, + MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT, + (), ) -HTTP_ENUM_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpEnumPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/EnumPayload", "method": "POST"}), - ) - ], +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT = ( + 18, + n1, + _MCTWGSI, + 0, + (_p,), + ((3, 16),), ) -HTTP_PAYLOAD_TRAITS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadTraitsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadTraitsInputOutput", +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT = (18, n1, _MCTWGSO, {_sSI: _sU}) + +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING = ( + 23, + n1, + _MCTWGS, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithGenericString"} ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, }, + MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT, + MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT, + (), ) -HTTP_PAYLOAD_TRAITS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadTraitsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadTraitsInputOutput", +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT = (18, n1, _MCTWBIa, {_sSI: _sU}) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT = (18, n1, _MCTWBOa, {_sSI: _sU}) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY = ( + 23, + n1, + _MCTWBa, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithoutBody"} ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, }, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT, + (), ) -HTTP_PAYLOAD_TRAITS = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadTraits"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPayloadTraits", "method": "POST"}), - ) - ], +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT = ( + 18, + n1, + _MCTWBEII, + 0, + (_he,), + ((3, {_sH: _he}),), ) -TEXT_PLAIN_BLOB = Schema( - id=ShapeID("aws.protocoltests.shared#TextPlainBlob"), - shape_type=ShapeType.BLOB, - traits=[Trait.new(id=ShapeID("smithy.api#mediaType"), value="text/plain")], +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT = ( + 18, + n1, + _MCTWBEIO, + {_sSI: _sU}, ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadTraitsWithMediaTypeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadTraitsWithMediaTypeInputOutput", +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT = ( + 23, + n1, + _MCTWBEI, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithoutBodyEmptyInput"} ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": TEXT_PLAIN_BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, }, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT, + (), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadTraitsWithMediaTypeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadTraitsWithMediaTypeInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": TEXT_PLAIN_BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT = ( + 18, + n1, + _MCTWPI, + 0, + (_p,), + ((JPEG_BLOB, 16),), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadTraitsWithMediaType"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadTraitsWithMediaType", "method": "POST"} - ), +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT = (18, n1, _MCTWPO, {_sSI: _sU}) + +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD = ( + 23, + n1, + _MCTWP, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithPayload"} ) - ], + }, + MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT, + MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT, + (), ) -NESTED_PAYLOAD = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NestedPayload"), - members={"greeting": {"target": STRING}, "name": {"target": STRING}}, +MALFORMED_DOUBLE_INPUT = ( + 18, + n1, + _MDI, + 0, + (_dIB, _dIP, _dIQ, _dIH), + ((10, 0), (10, 9), (10, {_sQ: _dIQ}), (10, {_sH: _dIH})), ) -HTTP_PAYLOAD_WITH_STRUCTURE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadWithStructureInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadWithStructureInputOutput", - ) - ], - members={ - "nested": { - "target": NESTED_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +MALFORMED_DOUBLE_OUTPUT = (18, n1, _MDO, {_sSI: _sU}) -HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadWithStructureOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadWithStructureInputOutput", +MALFORMED_DOUBLE = ( + 23, + n1, + _MD, + { + _s: MappingProxyType( + {"uri": "/MalformedDouble/{doubleInPath}", "method": "POST"} ) - ], - members={ - "nested": { - "target": NESTED_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } }, + MALFORMED_DOUBLE_INPUT, + MALFORMED_DOUBLE_OUTPUT, + (), ) -HTTP_PAYLOAD_WITH_STRUCTURE = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadWithStructure"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadWithStructure", "method": "PUT"} - ), - ) - ], +MALFORMED_FLOAT_INPUT = ( + 18, + n1, + _MFI, + 0, + (_fIB, _fIP, _fIQ, _fIH), + ((9, 0), (9, 9), (9, {_sQ: _fIQ}), (9, {_sH: _fIH})), ) -UNION_PAYLOAD = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#UnionPayload"), - shape_type=ShapeType.UNION, - members={"greeting": {"target": STRING}}, -) +MALFORMED_FLOAT_OUTPUT = (18, n1, _MFO, {_sSI: _sU}) -HTTP_PAYLOAD_WITH_UNION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadWithUnionInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadWithUnionInputOutput", - ) - ], - members={ - "nested": { - "target": UNION_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +MALFORMED_FLOAT = ( + 23, + n1, + _MF, + {_s: MappingProxyType({"uri": "/MalformedFloat/{floatInPath}", "method": "POST"})}, + MALFORMED_FLOAT_INPUT, + MALFORMED_FLOAT_OUTPUT, + (), ) -HTTP_PAYLOAD_WITH_UNION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadWithUnionOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpPayloadWithUnionInputOutput", - ) - ], - members={ - "nested": { - "target": UNION_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +MALFORMED_INTEGER_INPUT = ( + 18, + n1, + _MII, + 0, + (_iIB, _iIP, _iIQ, _iIH), + ((7, 0), (7, 9), (7, {_sQ: _iIQ}), (7, {_sH: _iIH})), ) -HTTP_PAYLOAD_WITH_UNION = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpPayloadWithUnion"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPayloadWithUnion", "method": "PUT"}), +MALFORMED_INTEGER_OUTPUT = (18, n1, _MIO, {_sSI: _sU}) + +MALFORMED_INTEGER = ( + 23, + n1, + _MI, + { + _s: MappingProxyType( + {"uri": "/MalformedInteger/{integerInPath}", "method": "POST"} ) - ], -) - -HTTP_PREFIX_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPrefixHeadersInput"), - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-foo")], - }, - "fooMap": { - "target": STRING_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="x-foo-") - ], - }, }, + MALFORMED_INTEGER_INPUT, + MALFORMED_INTEGER_OUTPUT, + (), ) -HTTP_PREFIX_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPrefixHeadersOutput"), - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-foo")], - }, - "fooMap": { - "target": STRING_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="x-foo-") - ], - }, - }, +SIMPLE_LIST = (16, n1, _SLi, 0, (_m,), ((3, 0),)) + +MALFORMED_LIST_INPUT = (18, n1, _MLI, 0, (_bLo,), ((SIMPLE_LIST, 0),)) + +MALFORMED_LIST_OUTPUT = (18, n1, _MLO, {_sSI: _sU}) + +MALFORMED_LIST = ( + 23, + n1, + _ML, + {_s: MappingProxyType({"uri": "/MalformedList", "method": "POST"})}, + MALFORMED_LIST_INPUT, + MALFORMED_LIST_OUTPUT, + (), ) -HTTP_PREFIX_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpPrefixHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPrefixHeaders", "method": "GET"}), - ) - ], +MALFORMED_LONG_INPUT = ( + 18, + n1, + _MLIa, + 0, + (_lIB, _lIP, _lIQ, _lIH), + ((8, 0), (8, 9), (8, {_sQ: _lIQ}), (8, {_sH: _lIH})), ) -HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPrefixHeadersInResponseInput") +MALFORMED_LONG_OUTPUT = (18, n1, _MLOa, {_sSI: _sU}) + +MALFORMED_LONG = ( + 23, + n1, + _MLa, + {_s: MappingProxyType({"uri": "/MalformedLong/{longInPath}", "method": "POST"})}, + MALFORMED_LONG_INPUT, + MALFORMED_LONG_OUTPUT, + (), ) -HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpPrefixHeadersInResponseOutput"), - members={ - "prefixHeaders": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="")], - } - }, +SIMPLE_MAP = (17, n1, _SMi, 0, (_k, _v), ((3, 0), (3, 0))) + +MALFORMED_MAP_INPUT = (18, n1, _MMI, 0, (_bM,), ((SIMPLE_MAP, 0),)) + +MALFORMED_MAP_OUTPUT = (18, n1, _MMO, {_sSI: _sU}) + +MALFORMED_MAP = ( + 23, + n1, + _MM, + {_s: MappingProxyType({"uri": "/MalformedMap", "method": "POST"})}, + MALFORMED_MAP_INPUT, + MALFORMED_MAP_OUTPUT, + (), ) -HTTP_PREFIX_HEADERS_IN_RESPONSE = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpPrefixHeadersInResponse"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPrefixHeadersResponse", "method": "GET"} - ), - ) - ], +MALFORMED_REQUEST_BODY_INPUT = (18, n1, _MRBI, 0, (_in, _fl), ((7, 0), (9, 0))) + +MALFORMED_REQUEST_BODY_OUTPUT = (18, n1, _MRBO, {_sSI: _sU}) + +MALFORMED_REQUEST_BODY = ( + 23, + n1, + _MRB, + {_s: MappingProxyType({"uri": "/MalformedRequestBody", "method": "POST"})}, + MALFORMED_REQUEST_BODY_INPUT, + MALFORMED_REQUEST_BODY_OUTPUT, + (), ) -QUERY_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, +MALFORMED_SHORT_INPUT = ( + 18, + n1, + _MSI, + 0, + (_sIB, _sIP, _sIQ, _sIH), + ((6, 0), (6, 9), (6, {_sQ: _sIQ}), (6, {_sH: _sIH})), ) -HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpQueryParamsOnlyOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#HttpQueryParamsOnlyInput", - ) - ], - members={ - "queryMap": { - "target": QUERY_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - } - }, +MALFORMED_SHORT_OUTPUT = (18, n1, _MSO, {_sSI: _sU}) + +MALFORMED_SHORT = ( + 23, + n1, + _MS, + {_s: MappingProxyType({"uri": "/MalformedShort/{shortInPath}", "method": "POST"})}, + MALFORMED_SHORT_INPUT, + MALFORMED_SHORT_OUTPUT, + (), ) -HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpQueryParamsOnlyOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +MALFORMED_STRING_INPUT = ( + 18, + n1, + _MSIa, + 0, + (_bl,), + ((JSON_HEADER_STRING, {_sH: _amth}),), ) -HTTP_QUERY_PARAMS_ONLY_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpQueryParamsOnlyOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/http-query-params-only", "method": "GET"}), - ) - ], -) - -HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithFloatLabelsInput"), - members={ - "float": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "double": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - }, +MALFORMED_STRING_OUTPUT = (18, n1, _MSOa, {_sSI: _sU}) + +MALFORMED_STRING = ( + 23, + n1, + _MSa, + {_s: MappingProxyType({"uri": "/MalformedString", "method": "POST"})}, + MALFORMED_STRING_INPUT, + MALFORMED_STRING_OUTPUT, + (), ) -HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithFloatLabelsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_FLOAT_LABELS = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithFloatLabels"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "GET", "uri": "/FloatHttpLabels/{float}/{double}"} - ), - ) - ], -) - -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithGreedyLabelInPathInput"), - members={ - "foo": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "baz": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - }, +MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT = ( + 18, + n1, + _MTBDTI, + 0, + (_ti,), + ((4, {_sF: _dt, _smit: None}),), ) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithGreedyLabelInPathOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithGreedyLabelInPath"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "method": "GET", - "uri": "/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}", - } - ), +MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT = (18, n1, _MTBDTO, {_sSI: _sU}) + +MALFORMED_TIMESTAMP_BODY_DATE_TIME = ( + 23, + n1, + _MTBDT, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampBodyDateTime", "method": "POST"} ) - ], -) - -HTTP_REQUEST_WITH_LABELS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithLabelsInput"), - members={ - "string": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "short": { - "target": SHORT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "integer": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "long": { - "target": LONG, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "float": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "double": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "boolean": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, }, + MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT, + MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT, + (), ) -HTTP_REQUEST_WITH_LABELS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithLabelsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_LABELS = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithLabels"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "method": "GET", - "uri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}", - } - ), - ) - ], -) +MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT = (18, n1, _MTBDI, 0, (_ti,), ((4, 1),)) -EPOCH_SECONDS = Schema( - id=ShapeID("aws.protocoltests.shared#EpochSeconds"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds")], -) +MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT = (18, n1, _MTBDO, {_sSI: _sU}) -HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.shared#HttpDate"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date")], +MALFORMED_TIMESTAMP_BODY_DEFAULT = ( + 23, + n1, + _MTBD, + {_s: MappingProxyType({"uri": "/MalformedTimestampBodyDefault", "method": "POST"})}, + MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT, + (), ) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restjson#HttpRequestWithLabelsAndTimestampFormatInput" - ), - members={ - "memberEpochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "memberHttpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "memberDateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "defaultFormat": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "targetEpochSeconds": { - "target": EPOCH_SECONDS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "targetHttpDate": { - "target": HTTP_DATE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "targetDateTime": { - "target": DATE_TIME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - }, +MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT = ( + 18, + n1, + _MTBHDI, + 0, + (_ti,), + ((4, {_sF: _hd, _smit: None}),), ) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restjson#HttpRequestWithLabelsAndTimestampFormatOutput" - ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithLabelsAndTimestampFormat"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "method": "GET", - "uri": "/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}", - } - ), +MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT = (18, n1, _MTBHDO, {_sSI: _sU}) + +MALFORMED_TIMESTAMP_BODY_HTTP_DATE = ( + 23, + n1, + _MTBHD, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampBodyHttpDate", "method": "POST"} ) - ], -) - -HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithRegexLiteralInput"), - members={ - "str": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } }, + MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT, + MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT, + (), ) -HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithRegexLiteralOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_REGEX_LITERAL = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpRequestWithRegexLiteral"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "GET", "uri": "/ReDosLiteral/{str}/(a+)+"} - ), - ) - ], +MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT = ( + 18, + n1, + _MTHDTI, + 0, + (_ti,), + ((4, {_sF: _dt, _sH: _ti, _smit: None}),), ) -HTTP_RESPONSE_CODE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpResponseCodeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT = (18, n1, _MTHDTO, {_sSI: _sU}) -HTTP_RESPONSE_CODE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpResponseCodeOutput"), - members={ - "Status": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#httpResponseCode"))], - } +MALFORMED_TIMESTAMP_HEADER_DATE_TIME = ( + 23, + n1, + _MTHDT, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampHeaderDateTime", "method": "POST"} + ) }, + MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT, + MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT, + (), ) -HTTP_RESPONSE_CODE = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpResponseCode"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpResponseCode", "method": "PUT"}), - ) - ], +MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT = ( + 18, + n1, + _MTHDI, + 0, + (_ti,), + ((4, {_sH: _ti, _smit: None}),), ) -HTTP_STRING_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpStringPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#StringPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT = (18, n1, _MTHDO, {_sSI: _sU}) -HTTP_STRING_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#HttpStringPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#StringPayloadInput", +MALFORMED_TIMESTAMP_HEADER_DEFAULT = ( + 23, + n1, + _MTHD, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampHeaderDefault", "method": "POST"} ) - ], - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } }, + MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT, + (), ) -HTTP_STRING_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#HttpStringPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/StringPayload", "method": "POST"}), - ) - ], +MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT = ( + 18, + n1, + _MTHEI, + 0, + (_ti,), + ((4, {_sF: _es, _sH: _ti, _smit: None}),), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#IgnoreQueryParamsInResponseInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT = (18, n1, _MTHEO, {_sSI: _sU}) + +MALFORMED_TIMESTAMP_HEADER_EPOCH = ( + 23, + n1, + _MTHE, + {_s: MappingProxyType({"uri": "/MalformedTimestampHeaderEpoch", "method": "POST"})}, + MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT, + MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT, + (), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#IgnoreQueryParamsInResponseOutput"), - members={ - "baz": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="baz")], - } +MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT = (18, n1, _MTPDI, 0, (_ti,), ((4, 9),)) + +MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT = (18, n1, _MTPDO, {_sSI: _sU}) + +MALFORMED_TIMESTAMP_PATH_DEFAULT = ( + 23, + n1, + _MTPD, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampPathDefault/{timestamp}", "method": "POST"} + ) }, + MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT, + (), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE = Schema( - id=ShapeID("aws.protocoltests.restjson#IgnoreQueryParamsInResponse"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/IgnoreQueryParamsInResponse", "method": "GET"} - ), - ) - ], +MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT = ( + 18, + n1, + _MTPEI, + 0, + (_ti,), + ((4, {_sF: _es, _smit: None, _sL: None}),), ) -INPUT_AND_OUTPUT_WITH_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InputAndOutputWithHeadersInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#InputAndOutputWithHeadersIO", +MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT = (18, n1, _MTPEO, {_sSI: _sU}) + +MALFORMED_TIMESTAMP_PATH_EPOCH = ( + 23, + n1, + _MTPE, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampPathEpoch/{timestamp}", "method": "POST"} ) - ], - members={ - "headerString": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-String") - ], - }, - "headerByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Byte")], - }, - "headerShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Short")], - }, - "headerInteger": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Integer") - ], - }, - "headerLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Long")], - }, - "headerFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Float")], - }, - "headerDouble": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Double") - ], - }, - "headerTrueBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean1") - ], - }, - "headerFalseBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean2") - ], - }, - "headerStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringList") - ], - }, - "headerStringSet": { - "target": STRING_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringSet") - ], - }, - "headerIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-IntegerList") - ], - }, - "headerBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-BooleanList") - ], - }, - "headerTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-TimestampList") - ], - }, - "headerEnum": { - "target": FOO_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Enum")], - }, - "headerEnumList": { - "target": FOO_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-EnumList") - ], - }, - "headerIntegerEnum": { - "target": INTEGER_ENUM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-IntegerEnum") - ], - }, - "headerIntegerEnumList": { - "target": INTEGER_ENUM_LIST, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-IntegerEnumList" - ) - ], - }, }, + MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT, + MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT, + (), ) -INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InputAndOutputWithHeadersOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#InputAndOutputWithHeadersIO", +MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT = ( + 18, + n1, + _MTPHDI, + 0, + (_ti,), + ((4, {_sF: _hd, _smit: None, _sL: None}),), +) + +MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT = (18, n1, _MTPHDO, {_sSI: _sU}) + +MALFORMED_TIMESTAMP_PATH_HTTP_DATE = ( + 23, + n1, + _MTPHD, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampPathHttpDate/{timestamp}", "method": "POST"} ) - ], - members={ - "headerString": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-String") - ], - }, - "headerByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Byte")], - }, - "headerShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Short")], - }, - "headerInteger": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Integer") - ], - }, - "headerLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Long")], - }, - "headerFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Float")], - }, - "headerDouble": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Double") - ], - }, - "headerTrueBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean1") - ], - }, - "headerFalseBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean2") - ], - }, - "headerStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringList") - ], - }, - "headerStringSet": { - "target": STRING_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringSet") - ], - }, - "headerIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-IntegerList") - ], - }, - "headerBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-BooleanList") - ], - }, - "headerTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-TimestampList") - ], - }, - "headerEnum": { - "target": FOO_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Enum")], - }, - "headerEnumList": { - "target": FOO_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-EnumList") - ], - }, - "headerIntegerEnum": { - "target": INTEGER_ENUM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-IntegerEnum") - ], - }, - "headerIntegerEnumList": { - "target": INTEGER_ENUM_LIST, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-IntegerEnumList" - ) - ], - }, }, + MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT, + MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT, + (), ) -INPUT_AND_OUTPUT_WITH_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restjson#InputAndOutputWithHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/InputAndOutputWithHeaders", "method": "POST"} - ), - ) - ], +MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT = ( + 18, + n1, + _MTQDI, + 0, + (_ti,), + ((4, {_sQ: _ti, _smit: None}),), ) -INPUT_STREAM_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InputStreamInput"), - members={ - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -INPUT_STREAM_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InputStreamOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -INPUT_STREAM = Schema( - id=ShapeID("aws.protocoltests.restjson#InputStream"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"method": "POST", "uri": "/InputStream"}), - ) - ], -) - -INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InputStreamWithInitialRequestInput"), - members={ - "initialRequestMember": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="initial-request-member" - ), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) - -INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#InputStreamWithInitialRequestOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -INPUT_STREAM_WITH_INITIAL_REQUEST = Schema( - id=ShapeID("aws.protocoltests.restjson#InputStreamWithInitialRequest"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/InputStreamWithInitialRequest"} - ), - ) - ], -) - -JSON_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonBlobsInputOutput", - ) - ], - members={"data": {"target": BLOB}}, -) - -JSON_BLOBS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonBlobsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonBlobsInputOutput", - ) - ], - members={"data": {"target": BLOB}}, -) - -JSON_BLOBS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonBlobs"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonBlobs", "method": "POST"}), - ) - ], -) - -FOO_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": FOO_ENUM}}, -) - -FOO_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) - -JSON_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonEnumsInputOutput", - ) - ], - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, -) - -JSON_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonEnumsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonEnumsInputOutput", - ) - ], - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, -) - -JSON_ENUMS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonEnums"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonEnums", "method": "PUT"}), - ) - ], -) - -JSON_HEADER_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonHeaderString"), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#mediaType"), value="application/json")], -) - -INTEGER_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER_ENUM}}, -) - -INTEGER_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) - -JSON_INT_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonIntEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonIntEnumsInputOutput", - ) - ], - members={ - "integerEnum1": {"target": INTEGER_ENUM}, - "integerEnum2": {"target": INTEGER_ENUM}, - "integerEnum3": {"target": INTEGER_ENUM}, - "integerEnumList": {"target": INTEGER_ENUM_LIST}, - "integerEnumSet": {"target": INTEGER_ENUM_SET}, - "integerEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -JSON_INT_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonIntEnumsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonIntEnumsInputOutput", - ) - ], - members={ - "integerEnum1": {"target": INTEGER_ENUM}, - "integerEnum2": {"target": INTEGER_ENUM}, - "integerEnum3": {"target": INTEGER_ENUM}, - "integerEnumList": {"target": INTEGER_ENUM_LIST}, - "integerEnumSet": {"target": INTEGER_ENUM_SET}, - "integerEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -JSON_INT_ENUMS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonIntEnums"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonIntEnums", "method": "PUT"}), - ) - ], -) - -NESTED_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#NestedStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING_LIST}}, -) - -STRUCTURE_LIST_MEMBER = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StructureListMember"), - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="value")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="other")], - }, - }, -) - -STRUCTURE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StructureList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRUCTURE_LIST_MEMBER}}, -) - -JSON_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonListsInputOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#jsonName"), value="myStructureList") - ], - }, - }, -) +MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT = (18, n1, _MTQDO, {_sSI: _sU}) -JSON_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonListsInputOutput", +MALFORMED_TIMESTAMP_QUERY_DEFAULT = ( + 23, + n1, + _MTQD, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampQueryDefault", "method": "POST"} ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#jsonName"), value="myStructureList") - ], - }, }, + MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT, + (), ) -JSON_LISTS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonLists"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonLists", "method": "PUT"}), - ) - ], -) - -JSON_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonMapsInputOutput", - ) - ], - members={ - "denseStructMap": {"target": DENSE_STRUCT_MAP}, - "denseNumberMap": {"target": DENSE_NUMBER_MAP}, - "denseBooleanMap": {"target": DENSE_BOOLEAN_MAP}, - "denseStringMap": {"target": DENSE_STRING_MAP}, - "denseSetMap": {"target": DENSE_SET_MAP}, - }, -) - -JSON_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonMapsInputOutput", - ) - ], - members={ - "denseStructMap": {"target": DENSE_STRUCT_MAP}, - "denseNumberMap": {"target": DENSE_NUMBER_MAP}, - "denseBooleanMap": {"target": DENSE_BOOLEAN_MAP}, - "denseStringMap": {"target": DENSE_STRING_MAP}, - "denseSetMap": {"target": DENSE_SET_MAP}, - }, -) - -JSON_MAPS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonMaps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonMaps", "method": "POST"}), - ) - ], -) - -JSON_TIMESTAMPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonTimestampsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonTimestampsInputOutput", - ) - ], - members={ - "normal": {"target": TIMESTAMP}, - "dateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "dateTimeOnTarget": {"target": DATE_TIME}, - "epochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochSecondsOnTarget": {"target": EPOCH_SECONDS}, - "httpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "httpDateOnTarget": {"target": HTTP_DATE}, - }, +MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT = ( + 18, + n1, + _MTQEI, + 0, + (_ti,), + ((4, {_sF: _es, _sQ: _ti, _smit: None}),), ) -JSON_TIMESTAMPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonTimestampsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#JsonTimestampsInputOutput", - ) - ], - members={ - "normal": {"target": TIMESTAMP}, - "dateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "dateTimeOnTarget": {"target": DATE_TIME}, - "epochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochSecondsOnTarget": {"target": EPOCH_SECONDS}, - "httpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "httpDateOnTarget": {"target": HTTP_DATE}, - }, -) - -JSON_TIMESTAMPS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonTimestamps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonTimestamps", "method": "POST"}), - ) - ], -) - -RENAMED_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.restjson.nested#GreetingStruct"), - members={"salutation": {"target": STRING}}, -) - -NESTED_UNION = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NestedUnion"), - shape_type=ShapeType.UNION, - members={"stringValue": {"target": STRING}}, -) - -MY_UNION = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MyUnion"), - shape_type=ShapeType.UNION, - members={ - "stringValue": {"target": STRING}, - "booleanValue": {"target": BOOLEAN}, - "numberValue": {"target": INTEGER}, - "blobValue": {"target": BLOB}, - "timestampValue": {"target": TIMESTAMP}, - "enumValue": {"target": FOO_ENUM}, - "listValue": {"target": STRING_LIST}, - "mapValue": {"target": STRING_MAP}, - "structureValue": {"target": GREETING_STRUCT}, - "renamedStructureValue": {"target": RENAMED_GREETING}, - "unionValue": {"target": NESTED_UNION}, - }, -) - -JSON_UNIONS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonUnionsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#UnionInputOutput", - ) - ], - members={"contents": {"target": MY_UNION}}, -) - -JSON_UNIONS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#JsonUnionsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#UnionInputOutput", - ) - ], - members={"contents": {"target": MY_UNION}}, -) - -JSON_UNIONS = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonUnions"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/JsonUnions", "method": "PUT"}), - ) - ], -) +MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT = (18, n1, _MTQEO, {_sSI: _sU}) -JSON_VALUE = Schema( - id=ShapeID("aws.protocoltests.restjson#JsonValue"), - shape_type=ShapeType.STRING, - traits=[Trait.new(id=ShapeID("smithy.api#mediaType"), value="application/json")], +MALFORMED_TIMESTAMP_QUERY_EPOCH = ( + 23, + n1, + _MTQE, + {_s: MappingProxyType({"uri": "/MalformedTimestampQueryEpoch", "method": "POST"})}, + MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT, + MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT, + (), ) -MALFORMED_ACCEPT_WITH_BODY_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithBodyInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT = ( + 18, + n1, + _MTQHDI, + 0, + (_ti,), + ((4, {_sF: _hd, _sQ: _ti, _smit: None}),), ) -MALFORMED_ACCEPT_WITH_BODY_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithBodyOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.shared#GreetingStruct", - ) - ], - members={"hi": {"target": STRING}}, -) - -MALFORMED_ACCEPT_WITH_BODY = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithBody"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedAcceptWithBody"} - ), - ) - ], -) +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT = (18, n1, _MTQHDO, {_sSI: _sU}) -MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithGenericStringInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE = ( + 23, + n1, + _MTQHD, + { + _s: MappingProxyType( + {"uri": "/MalformedTimestampQueryHttpDate", "method": "POST"} ) - ], -) - -MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithGenericStringOutput"), - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } }, + MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT, + MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT, + (), ) -MALFORMED_ACCEPT_WITH_GENERIC_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithGenericString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedAcceptWithGenericString"} - ), - ) - ], -) - -MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +SIMPLE_UNION = (19, n1, _SU, 0, (_in, _str), ((7, 0), (3, 0))) -JPEG_BLOB = Schema( - id=ShapeID("aws.protocoltests.shared#JpegBlob"), - shape_type=ShapeType.BLOB, - traits=[Trait.new(id=ShapeID("smithy.api#mediaType"), value="image/jpeg")], -) +MALFORMED_UNION_INPUT = (18, n1, _MUI, 0, (_u,), ((SIMPLE_UNION, 0),)) -MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithPayloadOutput"), - members={ - "payload": { - "target": JPEG_BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +MALFORMED_UNION_OUTPUT = (18, n1, _MUO, {_sSI: _sU}) -MALFORMED_ACCEPT_WITH_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedAcceptWithPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedAcceptWithPayload"} - ), - ) - ], +MALFORMED_UNION = ( + 23, + n1, + _MUa, + {_s: MappingProxyType({"uri": "/MalformedUnion", "method": "POST"})}, + MALFORMED_UNION_INPUT, + MALFORMED_UNION_OUTPUT, + (), ) -MALFORMED_BLOB_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedBlobInput"), - members={"blob": {"target": BLOB}}, -) +MEDIA_TYPE_HEADER_INPUT = (18, n1, _MTHI, 0, (_j,), ((JSON_VALUE, {_sH: _XJ}),)) -MALFORMED_BLOB_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedBlobOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +MEDIA_TYPE_HEADER_OUTPUT = (18, n1, _MTHO, 0, (_j,), ((JSON_VALUE, {_sH: _XJ}),)) -MALFORMED_BLOB = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedBlob"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MalformedBlob", "method": "POST"}), - ) - ], -) - -MALFORMED_BOOLEAN_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedBooleanInput"), - members={ - "booleanInBody": {"target": BOOLEAN}, - "booleanInPath": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "booleanInQuery": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="booleanInQuery") - ], - }, - "booleanInHeader": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="booleanInHeader") - ], - }, - }, +MEDIA_TYPE_HEADER = ( + 23, + n1, + _MTH, + {_s: MappingProxyType({"uri": "/MediaTypeHeader", "method": "GET"})}, + MEDIA_TYPE_HEADER_INPUT, + MEDIA_TYPE_HEADER_OUTPUT, + (), ) -MALFORMED_BOOLEAN_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedBooleanOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_BOOLEAN = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedBoolean"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedBoolean/{booleanInPath}", "method": "POST"} - ), - ) - ], -) - -MALFORMED_BYTE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedByteInput"), - members={ - "byteInBody": {"target": BYTE}, - "byteInPath": { - "target": BYTE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "byteInQuery": { - "target": BYTE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="byteInQuery") - ], - }, - "byteInHeader": { - "target": BYTE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="byteInHeader") - ], - }, - }, -) +NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n1, _NIANOI, {_sSI: _sU}) -MALFORMED_BYTE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedByteOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_BYTE = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedByte"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedByte/{byteInPath}", "method": "POST"} - ), - ) - ], -) +NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n1, _NIANOO, {_sSI: _sU}) -MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithBodyInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.shared#GreetingStruct", - ) - ], - members={"hi": {"target": STRING}}, +NO_INPUT_AND_NO_OUTPUT = ( + 23, + n1, + _NIANO, + {_s: MappingProxyType({"uri": "/NoInputAndNoOutput", "method": "POST"})}, + NO_INPUT_AND_NO_OUTPUT_INPUT, + NO_INPUT_AND_NO_OUTPUT_OUTPUT, + (), ) -MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithBodyOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITH_BODY = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithBody"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedContentTypeWithBody"} - ), - ) - ], -) +NO_INPUT_AND_OUTPUT_INPUT = (18, n1, _NIAOI, {_sSI: _sU}) -MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithGenericStringInput"), - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +NO_INPUT_AND_OUTPUT_OUTPUT = (18, n1, _NIAOO, 0) -MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restjson#MalformedContentTypeWithGenericStringOutput" +NO_INPUT_AND_OUTPUT = ( + 23, + n1, + _NIAO, + {_s: MappingProxyType({"uri": "/NoInputAndOutputOutput", "method": "POST"})}, + NO_INPUT_AND_OUTPUT_INPUT, + NO_INPUT_AND_OUTPUT_OUTPUT, + (), +) + +NULL_AND_EMPTY_HEADERS_CLIENT_INPUT = ( + 18, + n1, + _NAEHCI, + {_sSI: _aNAEHIO}, + (_a_, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT = ( + 18, + n1, + _NAEHCO, + {_sSI: _aNAEHIO}, + (_a_, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_CLIENT = ( + 23, + n1, + _NAEHC, + {_s: MappingProxyType({"uri": "/NullAndEmptyHeadersClient", "method": "GET"})}, + NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, + NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, + (), +) + +NULL_AND_EMPTY_HEADERS_SERVER_INPUT = ( + 18, + n1, + _NAEHSI, + {_sSI: _aNAEHIO}, + (_a_, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT = ( + 18, + n1, + _NAEHSO, + {_sSI: _aNAEHIO}, + (_a_, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_SERVER = ( + 23, + n1, + _NAEHS, + {_s: MappingProxyType({"uri": "/NullAndEmptyHeadersServer", "method": "GET"})}, + NULL_AND_EMPTY_HEADERS_SERVER_INPUT, + NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, + (), +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT = ( + 18, + n1, + _ONSESI, + 0, + (_nVu, _eS), + ((3, {_sQ: _Nu}), (3, {_sQ: _Em})), +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT = (18, n1, _ONSESO, {_sSI: _sU}) + +OMITS_NULL_SERIALIZES_EMPTY_STRING = ( + 23, + n1, + _ONSES, + {_s: MappingProxyType({"uri": "/OmitsNullSerializesEmptyString", "method": "GET"})}, + OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, + OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, + (), +) + +OMITS_SERIALIZING_EMPTY_LISTS_INPUT = ( + 18, + n1, + _OSELI, + 0, + (_qSL, _qIL, _qDL, _qBL, _qTL, _qEL, _qIEL), + ( + (STRING_LIST, {_sQ: _SL}), + (INTEGER_LIST, {_sQ: _IL}), + (DOUBLE_LIST, {_sQ: _DL}), + (BOOLEAN_LIST, {_sQ: _BL}), + (TIMESTAMP_LIST, {_sQ: _TL}), + (FOO_ENUM_LIST, {_sQ: _EL}), + (INTEGER_ENUM_LIST, {_sQ: _IEL}), ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithGenericString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedContentTypeWithGenericString"} - ), - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithoutBodyInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithoutBodyOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITHOUT_BODY = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithoutBody"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedContentTypeWithoutBody"} - ), - ) - ], ) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restjson#MalformedContentTypeWithoutBodyEmptyInputInput" +OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT = (18, n1, _OSELO, {_sSI: _sU}) + +OMITS_SERIALIZING_EMPTY_LISTS = ( + 23, + n1, + _OSEL, + {_s: MappingProxyType({"uri": "/OmitsSerializingEmptyLists", "method": "POST"})}, + OMITS_SERIALIZING_EMPTY_LISTS_INPUT, + OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT, + (), +) + +OPERATION_WITH_DEFAULTS_INPUT = ( + 18, + n1, + _OWDI, + 0, + (_de, _cOD, _tLD, _oTLD), + ((DEFAULTS, 0), (CLIENT_OPTIONAL_DEFAULTS, 0), (3, {_sm: _hi}), (7, {_sm: 0})), +) + +OPERATION_WITH_DEFAULTS_OUTPUT = ( + 18, + n1, + _OWDO, + 0, + ( + _dS, + _dB, + _dL, + _dDM, + _dDS, + _dDB, + _dDL, + _dND, + _dT, + _dBe, + _dBef, + _dSe, + _dI, + _dLe, + _dF, + _dD, + _dM, + _dE, + _dIE, + _eS, + _fB, + _eB, + _zB, + _zS, + _zI, + _zL, + _zF, + _zD, ), - members={ - "header": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="header")], - } - }, -) - -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restjson#MalformedContentTypeWithoutBodyEmptyInputOutput" + ( + (3, {_sm: _hi}), + (2, {_sm: True}), + (TEST_STRING_LIST, {_sm: ()}), + (DOCUMENT, {_sm: None}), + (DOCUMENT, {_sm: _hi}), + (DOCUMENT, {_sm: True}), + (DOCUMENT, {_sm: ()}), + (DOCUMENT, {_sm: None}), + (4, {_sm: 0}), + (1, {_sm: _YWJ}), + (5, {_sm: 1}), + (6, {_sm: 1}), + (7, {_sm: 10}), + (8, {_sm: 100}), + (9, {_sm: 1.0}), + (10, {_sm: 1.0}), + (TEST_STRING_MAP, {_sm: None}), + (TEST_ENUM, {_sm: _FOO}), + (TEST_INT_ENUM, {_sm: 1}), + (3, {_sm: _v_}), + (2, {_sm: False}), + (1, {_sm: _v_}), + (5, {_sm: 0}), + (6, {_sm: 0}), + (7, {_sm: 0}), + (8, {_sm: 0}), + (9, {_sm: 0.0}), + (10, {_sm: 0.0}), ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithoutBodyEmptyInput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedContentTypeWithoutBodyEmptyInput"} - ), - ) - ], ) -MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithPayloadInput"), - members={ - "payload": { - "target": JPEG_BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +OPERATION_WITH_DEFAULTS = ( + 23, + n1, + _OWD, + {_s: MappingProxyType({"uri": "/OperationWithDefaults", "method": "POST"})}, + OPERATION_WITH_DEFAULTS_INPUT, + OPERATION_WITH_DEFAULTS_OUTPUT, + (), ) -MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_CONTENT_TYPE_WITH_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedContentTypeWithPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/MalformedContentTypeWithPayload"} - ), - ) - ], -) - -MALFORMED_DOUBLE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedDoubleInput"), - members={ - "doubleInBody": {"target": DOUBLE}, - "doubleInPath": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "doubleInQuery": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="doubleInQuery") - ], - }, - "doubleInHeader": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="doubleInHeader") - ], - }, - }, +TOP_LEVEL = ( + 18, + n1, + _TLo, + 0, + (_di, _dLi, _dMi), + ((DIALOG, 1), (DIALOG_LIST, {_sm: ()}), (DIALOG_MAP, {_sm: None})), ) -MALFORMED_DOUBLE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedDoubleOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_DOUBLE = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedDouble"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedDouble/{doubleInPath}", "method": "POST"} - ), - ) - ], -) - -MALFORMED_FLOAT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedFloatInput"), - members={ - "floatInBody": {"target": FLOAT}, - "floatInPath": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "floatInQuery": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="floatInQuery") - ], - }, - "floatInHeader": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="floatInHeader") - ], - }, - }, -) +OPERATION_WITH_NESTED_STRUCTURE_INPUT = (18, n1, _OWNSI, 0, (_tLo,), ((TOP_LEVEL, 1),)) -MALFORMED_FLOAT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedFloatOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_FLOAT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedFloat"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedFloat/{floatInPath}", "method": "POST"} - ), - ) - ], -) - -MALFORMED_INTEGER_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedIntegerInput"), - members={ - "integerInBody": {"target": INTEGER}, - "integerInPath": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "integerInQuery": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="integerInQuery") - ], - }, - "integerInHeader": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="integerInHeader") - ], - }, - }, +OPERATION_WITH_NESTED_STRUCTURE_OUTPUT = ( + 18, + n1, + _OWNSO, + 0, + (_di, _dLi, _dMi), + ((DIALOG, 1), (DIALOG_LIST, {_sm: ()}), (DIALOG_MAP, {_sm: None})), ) -MALFORMED_INTEGER_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedIntegerOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_INTEGER = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedInteger"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedInteger/{integerInPath}", "method": "POST"} - ), - ) - ], +OPERATION_WITH_NESTED_STRUCTURE = ( + 23, + n1, + _OWNS, + {_s: MappingProxyType({"uri": "/OperationWithNestedStructure", "method": "POST"})}, + OPERATION_WITH_NESTED_STRUCTURE_INPUT, + OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, + (), ) -SIMPLE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SimpleList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) +OUTPUT_STREAM_INPUT = (18, n1, _OSI, {_sSI: _sU}) + +OUTPUT_STREAM_OUTPUT = (18, n1, _OSO, 0, (_st,), ((EVENT_STREAM, 16),)) -MALFORMED_LIST_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedListInput"), - members={"bodyList": {"target": SIMPLE_LIST}}, +OUTPUT_STREAM = ( + 23, + n1, + _OS, + {_s: MappingProxyType({"method": "POST", "uri": "/OutputStream"})}, + OUTPUT_STREAM_INPUT, + OUTPUT_STREAM_OUTPUT, + (SERVICE_UNAVAILABLE_ERROR,), ) -MALFORMED_LIST_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedListOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT = (18, n1, _OSWIRI, {_sSI: _sU}) + +OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT = ( + 18, + n1, + _OSWIRO, + 0, + (_iRMn, _st), + ((3, {_sH: _irm_, _smit: None}), (EVENT_STREAM, 16)), ) -MALFORMED_LIST = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedList"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MalformedList", "method": "POST"}), +OUTPUT_STREAM_WITH_INITIAL_RESPONSE = ( + 23, + n1, + _OSWIR, + { + _s: MappingProxyType( + {"method": "POST", "uri": "/OutputStreamWithInitialResponse"} ) - ], -) - -MALFORMED_LONG_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedLongInput"), - members={ - "longInBody": {"target": LONG}, - "longInPath": { - "target": LONG, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "longInQuery": { - "target": LONG, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="longInQuery") - ], - }, - "longInHeader": { - "target": LONG, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="longInHeader") - ], - }, }, + OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT, + OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT, + (), ) -MALFORMED_LONG_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedLongOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_LONG = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedLong"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedLong/{longInPath}", "method": "POST"} - ), - ) - ], -) +PAYLOAD_CONFIG = (18, n1, _PC, 0, (_da,), ((7, 0),)) -SIMPLE_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SimpleMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) +PLAYER_ACTION = (19, n1, _PA, 0, (_q,), ((-1, 0),)) -MALFORMED_MAP_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedMapInput"), - members={"bodyMap": {"target": SIMPLE_MAP}}, -) +POST_PLAYER_ACTION_INPUT = (18, n1, _PPAI, 0, (_ac,), ((PLAYER_ACTION, 0),)) -MALFORMED_MAP_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedMapOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +POST_PLAYER_ACTION_OUTPUT = (18, n1, _PPAO, 0, (_ac,), ((PLAYER_ACTION, 1),)) -MALFORMED_MAP = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedMap"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MalformedMap", "method": "POST"}), - ) - ], +POST_PLAYER_ACTION = ( + 23, + n1, + _PPA, + {_s: MappingProxyType({"uri": "/PostPlayerAction", "method": "POST"})}, + POST_PLAYER_ACTION_INPUT, + POST_PLAYER_ACTION_OUTPUT, + (), ) -MALFORMED_REQUEST_BODY_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedRequestBodyInput"), - members={"int": {"target": INTEGER}, "float": {"target": FLOAT}}, +UNION_WITH_JSON_NAME = ( + 19, + n1, + _UWJN, + 0, + (_fo, _ba, _b), + ((3, {_sN: _FOO}), (3, 0), (3, {_sN: _baz})), ) -MALFORMED_REQUEST_BODY_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedRequestBodyOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +POST_UNION_WITH_JSON_NAME_INPUT = ( + 18, + n1, + _PUWJNI, + 0, + (_v,), + ((UNION_WITH_JSON_NAME, 0),), ) -MALFORMED_REQUEST_BODY = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedRequestBody"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MalformedRequestBody", "method": "POST"}), - ) - ], -) - -MALFORMED_SHORT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedShortInput"), - members={ - "shortInBody": {"target": SHORT}, - "shortInPath": { - "target": SHORT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "shortInQuery": { - "target": SHORT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="shortInQuery") - ], - }, - "shortInHeader": { - "target": SHORT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="shortInHeader") - ], - }, - }, +POST_UNION_WITH_JSON_NAME_OUTPUT = ( + 18, + n1, + _PUWJNO, + 0, + (_v,), + ((UNION_WITH_JSON_NAME, 1),), ) -MALFORMED_SHORT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedShortOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_SHORT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedShort"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedShort/{shortInPath}", "method": "POST"} - ), - ) - ], -) - -MALFORMED_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedStringInput"), - members={ - "blob": { - "target": JSON_HEADER_STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="amz-media-typed-header" - ) - ], - } - }, +POST_UNION_WITH_JSON_NAME = ( + 23, + n1, + _PUWJN, + {_s: MappingProxyType({"uri": "/PostUnionWithJsonName", "method": "POST"})}, + POST_UNION_WITH_JSON_NAME_INPUT, + POST_UNION_WITH_JSON_NAME_OUTPUT, + (), ) -MALFORMED_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +PUT_WITH_CONTENT_ENCODING_INPUT = ( + 18, + n1, + _PWCEI, + 0, + (_en, _da), + ((3, {_sH: _CE_}), (3, 0)), ) -MALFORMED_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MalformedString", "method": "POST"}), - ) - ], -) - -MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyDateTimeInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } +PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n1, _PWCEO, {_sSI: _sU}) + +PUT_WITH_CONTENT_ENCODING = ( + 23, + n1, + _PWCE, + { + _sC: MappingProxyType({"encodings": ("gzip",)}), + _s: MappingProxyType( + {"method": "POST", "uri": "/requestcompression/putcontentwithencoding"} + ), }, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), ) -MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyDateTimeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_BODY_DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyDateTime"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampBodyDateTime", "method": "POST"} - ), - ) - ], +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = ( + 18, + n1, + _QITAFI, + 0, + (_to,), + ((3, {_sQ: _to, _sTm: None}),), ) -MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyDefaultInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n1, _QITAFO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyDefaultOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_BODY_DEFAULT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyDefault"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampBodyDefault", "method": "POST"} - ), - ) - ], -) - -MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyHttpDateInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( + 23, + n1, + _QITAF, + {_s: MappingProxyType({"uri": "/QueryIdempotencyTokenAutoFill", "method": "POST"})}, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + (), ) -MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyHttpDateOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_BODY_HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampBodyHttpDate"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampBodyHttpDate", "method": "POST"} - ), - ) - ], -) - -MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderDateTimeInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="timestamp"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, +QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT = ( + 18, + n1, + _QPASLMI, + 0, + (_qu, _fo), + ((3, {_sQ: _cor}), (STRING_LIST_MAP, 1024)), ) -MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderDateTimeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_HEADER_DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderDateTime"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampHeaderDateTime", "method": "POST"} - ), - ) - ], -) - -MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderDefaultInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="timestamp"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, -) +QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT = (18, n1, _QPASLMO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderDefaultOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_HEADER_DEFAULT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderDefault"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampHeaderDefault", "method": "POST"} - ), - ) - ], +QUERY_PARAMS_AS_STRING_LIST_MAP = ( + 23, + n1, + _QPASLM, + {_s: MappingProxyType({"uri": "/StringListMap", "method": "POST"})}, + QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, + QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, + (), ) -MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderEpochInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="timestamp"), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, +QUERY_PRECEDENCE_INPUT = ( + 18, + n1, + _QPI, + 0, + (_fo, _b), + ((3, {_sQ: _ba}), (STRING_MAP, 1024)), ) -MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderEpochOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_HEADER_EPOCH = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampHeaderEpoch"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampHeaderEpoch", "method": "POST"} - ), - ) - ], -) - -MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathDefaultInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } - }, -) +QUERY_PRECEDENCE_OUTPUT = (18, n1, _QPO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathDefaultOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_PATH_DEFAULT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathDefault"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampPathDefault/{timestamp}", "method": "POST"} - ), - ) - ], +QUERY_PRECEDENCE = ( + 23, + n1, + _QP, + {_s: MappingProxyType({"uri": "/Precedence", "method": "POST"})}, + QUERY_PRECEDENCE_INPUT, + QUERY_PRECEDENCE_OUTPUT, + (), ) -MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathEpochInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } - }, -) +RESPONSE_CODE_HTTP_FALLBACK_INPUT = (18, n1, _RCHFI, {_sSI: _aRCHFIO}) -MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathEpochOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_PATH_EPOCH = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathEpoch"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampPathEpoch/{timestamp}", "method": "POST"} - ), - ) - ], -) - -MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathHttpDateInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } - }, -) +RESPONSE_CODE_HTTP_FALLBACK_OUTPUT = (18, n1, _RCHFO, {_sSI: _aRCHFIO}) -MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathHttpDateOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" +RESPONSE_CODE_HTTP_FALLBACK = ( + 23, + n1, + _RCHF, + { + _s: MappingProxyType( + {"method": "GET", "uri": "/responseCodeHttpFallback", "code": 201} ) - ], -) - -MALFORMED_TIMESTAMP_PATH_HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampPathHttpDate"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampPathHttpDate/{timestamp}", "method": "POST"} - ), - ) - ], -) - -MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryDefaultInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="timestamp"), - ], - } }, + RESPONSE_CODE_HTTP_FALLBACK_INPUT, + RESPONSE_CODE_HTTP_FALLBACK_OUTPUT, + (), ) -MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryDefaultOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_QUERY_DEFAULT = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryDefault"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampQueryDefault", "method": "POST"} - ), - ) - ], -) +RESPONSE_CODE_REQUIRED_INPUT = (18, n1, _RCRI, {_sSI: _sU}) -MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryEpochInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="timestamp"), - ], - } - }, -) +RESPONSE_CODE_REQUIRED_OUTPUT = (18, n1, _RCRO, 0, (_rC,), ((7, 129),)) -MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryEpochOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_QUERY_EPOCH = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryEpoch"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampQueryEpoch", "method": "POST"} - ), +RESPONSE_CODE_REQUIRED = ( + 23, + n1, + _RCR, + { + _s: MappingProxyType( + {"method": "GET", "uri": "/responseCodeRequired", "code": 200} ) - ], -) - -MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryHttpDateInput"), - members={ - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="timestamp"), - ], - } }, + RESPONSE_CODE_REQUIRED_INPUT, + RESPONSE_CODE_REQUIRED_OUTPUT, + (), ) -MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryHttpDateOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -MALFORMED_TIMESTAMP_QUERY_HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedTimestampQueryHttpDate"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/MalformedTimestampQueryHttpDate", "method": "POST"} - ), - ) - ], -) - -SIMPLE_UNION = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SimpleUnion"), - shape_type=ShapeType.UNION, - members={"int": {"target": INTEGER}, "string": {"target": STRING}}, +SIMPLE_SCALAR_PROPERTIES_INPUT = ( + 18, + n1, + _SSPI, + {_sSI: _aSSPIO}, + (_fo, _sV, _tBV, _fBV, _bVy, _sVh, _iV, _lVo, _fV, _dVo), + ( + (3, {_sH: _XF}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_sN: _DD}), + ), ) -MALFORMED_UNION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedUnionInput"), - members={"union": {"target": SIMPLE_UNION}}, +SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( + 18, + n1, + _SSPO, + {_sSI: _aSSPIO}, + (_fo, _sV, _tBV, _fBV, _bVy, _sVh, _iV, _lVo, _fV, _dVo), + ( + (3, {_sH: _XF}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_sN: _DD}), + ), ) -MALFORMED_UNION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MalformedUnionOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +SIMPLE_SCALAR_PROPERTIES = ( + 23, + n1, + _SSP, + {_s: MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"})}, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), ) -MALFORMED_UNION = Schema( - id=ShapeID("aws.protocoltests.restjson#MalformedUnion"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MalformedUnion", "method": "POST"}), - ) - ], -) +SPARSE_SHORT_LIST = (16, n0, _SSL, 64, (_m,), ((6, 0),)) -MEDIA_TYPE_HEADER_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MediaTypeHeaderInput"), - members={ - "json": { - "target": JSON_VALUE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Json")], - } - }, -) +SPARSE_STRING_LIST = (16, n0, _SSLp, 64, (_m,), ((3, 0),)) -MEDIA_TYPE_HEADER_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#MediaTypeHeaderOutput"), - members={ - "json": { - "target": JSON_VALUE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Json")], - } - }, +SPARSE_JSON_LISTS_INPUT = ( + 18, + n1, + _SJLI, + {_sSI: _aSJLIO}, + (_sSL, _sSLp), + ((SPARSE_STRING_LIST, 0), (SPARSE_SHORT_LIST, 0)), ) -MEDIA_TYPE_HEADER = Schema( - id=ShapeID("aws.protocoltests.restjson#MediaTypeHeader"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/MediaTypeHeader", "method": "GET"}), - ) - ], +SPARSE_JSON_LISTS_OUTPUT = ( + 18, + n1, + _SJLO, + {_sSI: _aSJLIO}, + (_sSL, _sSLp), + ((SPARSE_STRING_LIST, 0), (SPARSE_SHORT_LIST, 0)), ) -NO_INPUT_AND_NO_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NoInputAndNoOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +SPARSE_JSON_LISTS = ( + 23, + n1, + _SJL, + {_s: MappingProxyType({"uri": "/SparseJsonLists", "method": "PUT"})}, + SPARSE_JSON_LISTS_INPUT, + SPARSE_JSON_LISTS_OUTPUT, + (), ) -NO_INPUT_AND_NO_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NoInputAndNoOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +SPARSE_BOOLEAN_MAP = (17, n1, _SBM, 64, (_k, _v), ((3, 0), (2, 0))) -NO_INPUT_AND_NO_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restjson#NoInputAndNoOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/NoInputAndNoOutput", "method": "POST"}), - ) - ], -) +SPARSE_NUMBER_MAP = (17, n1, _SNM, 64, (_k, _v), ((3, 0), (7, 0))) -NO_INPUT_AND_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NoInputAndOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) +SPARSE_SET_MAP = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (STRING_SET, 0))) -NO_INPUT_AND_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NoInputAndOutputOutput") -) +SPARSE_STRING_MAP = (17, n0, _SSMp, 64, (_k, _v), ((3, 0), (3, 0))) -NO_INPUT_AND_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restjson#NoInputAndOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NoInputAndOutputOutput", "method": "POST"} - ), - ) - ], -) +SPARSE_STRUCT_MAP = (17, n1, _SSMpa, 64, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) -NULL_AND_EMPTY_HEADERS_CLIENT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NullAndEmptyHeadersClientInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, +SPARSE_JSON_MAPS_INPUT = ( + 18, + n1, + _SJMI, + {_sSI: _aSJMIO}, + (_sSM, _sNM, _sBM, _sSMp, _sSMpa), + ( + (SPARSE_STRUCT_MAP, 0), + (SPARSE_NUMBER_MAP, 0), + (SPARSE_BOOLEAN_MAP, 0), + (SPARSE_STRING_MAP, 0), + (SPARSE_SET_MAP, 0), + ), ) -NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NullAndEmptyHeadersClientOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, +SPARSE_JSON_MAPS_OUTPUT = ( + 18, + n1, + _SJMO, + {_sSI: _aSJMIO}, + (_sSM, _sNM, _sBM, _sSMp, _sSMpa), + ( + (SPARSE_STRUCT_MAP, 0), + (SPARSE_NUMBER_MAP, 0), + (SPARSE_BOOLEAN_MAP, 0), + (SPARSE_STRING_MAP, 0), + (SPARSE_SET_MAP, 0), + ), ) -NULL_AND_EMPTY_HEADERS_CLIENT = Schema( - id=ShapeID("aws.protocoltests.restjson#NullAndEmptyHeadersClient"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NullAndEmptyHeadersClient", "method": "GET"} - ), - ) - ], -) +SPARSE_JSON_MAPS = ( + 23, + n1, + _SJM, + {_s: MappingProxyType({"uri": "/SparseJsonMaps", "method": "POST"})}, + SPARSE_JSON_MAPS_INPUT, + SPARSE_JSON_MAPS_OUTPUT, + (), +) + +STREAMING_BLOB = (1, n1, _SB, {_smith: None}) -NULL_AND_EMPTY_HEADERS_SERVER_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NullAndEmptyHeadersServerInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, -) +STREAMING_TRAITS_INPUT = ( + 18, + n1, + _STI, + {_sSI: _aSTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (STREAMING_BLOB, {_sm: _v_, _sPm: None})), +) -NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#NullAndEmptyHeadersServerOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, +STREAMING_TRAITS_OUTPUT = ( + 18, + n1, + _STO, + {_sSI: _aSTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (STREAMING_BLOB, {_sm: _v_, _sPm: None})), +) + +STREAMING_TRAITS = ( + 23, + n1, + _ST, + {_s: MappingProxyType({"uri": "/StreamingTraits", "method": "POST"})}, + STREAMING_TRAITS_INPUT, + STREAMING_TRAITS_OUTPUT, + (), +) + +STREAMING_TRAITS_REQUIRE_LENGTH_INPUT = ( + 18, + n1, + _STRLI, + 0, + (_fo, _bl), + ((3, {_sH: _XF}), (FINITE_STREAMING_BLOB, {_sm: _v_, _sPm: None})), +) + +STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT = (18, n1, _STRLO, {_sSI: _sU}) + +STREAMING_TRAITS_REQUIRE_LENGTH = ( + 23, + n1, + _STRL, + {_s: MappingProxyType({"uri": "/StreamingTraitsRequireLength", "method": "POST"})}, + STREAMING_TRAITS_REQUIRE_LENGTH_INPUT, + STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT, + (), +) + +STREAMING_TEXT_PLAIN_BLOB = (1, n1, _STPB, {_smith: None, _sT: _t}) + +STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT = ( + 18, + n1, + _STWMTI, + {_sSI: _aSTWMTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (STREAMING_TEXT_PLAIN_BLOB, {_sm: _v_, _sPm: None})), +) + +STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT = ( + 18, + n1, + _STWMTO, + {_sSI: _aSTWMTIO}, + (_fo, _bl), + ((3, {_sH: _XF}), (STREAMING_TEXT_PLAIN_BLOB, {_sm: _v_, _sPm: None})), +) + +STREAMING_TRAITS_WITH_MEDIA_TYPE = ( + 23, + n1, + _STWMT, + {_s: MappingProxyType({"uri": "/StreamingTraitsWithMediaType", "method": "POST"})}, + STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT, + STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + (), +) + +TEST_CONFIG = (18, n1, _TC, 0, (_tim,), ((7, 0),)) + +TEST_BODY_STRUCTURE_INPUT = ( + 18, + n1, + _TBSI, + {_sSI: _aTBSIO}, + (_tI, _tC), + ((3, {_sH: _xati}), (TEST_CONFIG, 0)), +) + +TEST_BODY_STRUCTURE_OUTPUT = ( + 18, + n1, + _TBSO, + {_sSI: _aTBSIO}, + (_tI, _tC), + ((3, {_sH: _xati}), (TEST_CONFIG, 0)), +) + +TEST_BODY_STRUCTURE = ( + 23, + n1, + _TBS, + {_s: MappingProxyType({"uri": "/body", "method": "POST"})}, + TEST_BODY_STRUCTURE_INPUT, + TEST_BODY_STRUCTURE_OUTPUT, + (), +) + +TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT = (18, n1, _TGNINPI, {_sSI: _sU}) + +TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT = ( + 18, + n1, + _TGNINPO, + {_sSI: _aTNPIO}, + (_tI,), + ((3, {_sH: _XATI}),), +) + +TEST_GET_NO_INPUT_NO_PAYLOAD = ( + 23, + n1, + _TGNINP, + {_s: MappingProxyType({"uri": "/no_input_no_payload", "method": "GET"})}, + TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT, + TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT, + (), +) + +TEST_GET_NO_PAYLOAD_INPUT = ( + 18, + n1, + _TGNPI, + {_sSI: _aTNPIO}, + (_tI,), + ((3, {_sH: _XATI}),), +) + +TEST_GET_NO_PAYLOAD_OUTPUT = ( + 18, + n1, + _TGNPO, + {_sSI: _aTNPIO}, + (_tI,), + ((3, {_sH: _XATI}),), +) + +TEST_GET_NO_PAYLOAD = ( + 23, + n1, + _TGNP, + {_s: MappingProxyType({"uri": "/no_payload", "method": "GET"})}, + TEST_GET_NO_PAYLOAD_INPUT, + TEST_GET_NO_PAYLOAD_OUTPUT, + (), +) + +TEST_PAYLOAD_BLOB_INPUT = ( + 18, + n1, + _TPBI, + {_sSI: _aTPBIO}, + (_cT, _da), + ((3, {_sH: _CT}), (1, 16)), +) + +TEST_PAYLOAD_BLOB_OUTPUT = ( + 18, + n1, + _TPBO, + {_sSI: _aTPBIO}, + (_cT, _da), + ((3, {_sH: _CT}), (1, 16)), +) + +TEST_PAYLOAD_BLOB = ( + 23, + n1, + _TPBe, + {_s: MappingProxyType({"uri": "/blob_payload", "method": "POST"})}, + TEST_PAYLOAD_BLOB_INPUT, + TEST_PAYLOAD_BLOB_OUTPUT, + (), +) + +TEST_PAYLOAD_STRUCTURE_INPUT = ( + 18, + n1, + _TPSI, + {_sSI: _aTPSIO}, + (_tI, _pC), + ((3, {_sH: _xati}), (PAYLOAD_CONFIG, 16)), +) + +TEST_PAYLOAD_STRUCTURE_OUTPUT = ( + 18, + n1, + _TPSO, + {_sSI: _aTPSIO}, + (_tI, _pC), + ((3, {_sH: _xati}), (PAYLOAD_CONFIG, 16)), +) + +TEST_PAYLOAD_STRUCTURE = ( + 23, + n1, + _TPS, + {_s: MappingProxyType({"uri": "/payload", "method": "POST"})}, + TEST_PAYLOAD_STRUCTURE_INPUT, + TEST_PAYLOAD_STRUCTURE_OUTPUT, + (), +) + +TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT = (18, n1, _TPNINPI, {_sSI: _sU}) + +TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT = ( + 18, + n1, + _TPNINPO, + {_sSI: _aTNPIO}, + (_tI,), + ((3, {_sH: _XATI}),), +) + +TEST_POST_NO_INPUT_NO_PAYLOAD = ( + 23, + n1, + _TPNINP, + {_s: MappingProxyType({"uri": "/no_input_no_payload", "method": "POST"})}, + TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT, + TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT, + (), +) + +TEST_POST_NO_PAYLOAD_INPUT = ( + 18, + n1, + _TPNPI, + {_sSI: _aTNPIO}, + (_tI,), + ((3, {_sH: _XATI}),), +) + +TEST_POST_NO_PAYLOAD_OUTPUT = ( + 18, + n1, + _TPNPO, + {_sSI: _aTNPIO}, + (_tI,), + ((3, {_sH: _XATI}),), +) + +TEST_POST_NO_PAYLOAD = ( + 23, + n1, + _TPNP, + {_s: MappingProxyType({"uri": "/no_payload", "method": "POST"})}, + TEST_POST_NO_PAYLOAD_INPUT, + TEST_POST_NO_PAYLOAD_OUTPUT, + (), +) + +TIMESTAMP_FORMAT_HEADERS_INPUT = ( + 18, + n1, + _TFHI, + {_sSI: _aTFHIO}, + (_mES, _mHD, _mDT, _dFe, _tES, _tHD, _tDT), + ( + (4, {_sF: _es, _sH: _Xm}), + (4, {_sF: _hd, _sH: _Xm_}), + (4, {_sF: _dt, _sH: _Xm__}), + (4, {_sH: _Xd}), + (EPOCH_SECONDS, {_sH: _Xt}), + (HTTP_DATE, {_sH: _Xt_}), + (DATE_TIME, {_sH: _Xt__}), + ), ) -NULL_AND_EMPTY_HEADERS_SERVER = Schema( - id=ShapeID("aws.protocoltests.restjson#NullAndEmptyHeadersServer"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NullAndEmptyHeadersServer", "method": "GET"} - ), - ) - ], -) - -OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OmitsNullSerializesEmptyStringInput"), - members={ - "nullValue": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Null")], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Empty")], - }, - }, +TIMESTAMP_FORMAT_HEADERS_OUTPUT = ( + 18, + n1, + _TFHO, + {_sSI: _aTFHIO}, + (_mES, _mHD, _mDT, _dFe, _tES, _tHD, _tDT), + ( + (4, {_sF: _es, _sH: _Xm}), + (4, {_sF: _hd, _sH: _Xm_}), + (4, {_sF: _dt, _sH: _Xm__}), + (4, {_sH: _Xd}), + (EPOCH_SECONDS, {_sH: _Xt}), + (HTTP_DATE, {_sH: _Xt_}), + (DATE_TIME, {_sH: _Xt__}), + ), ) -OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OmitsNullSerializesEmptyStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -OMITS_NULL_SERIALIZES_EMPTY_STRING = Schema( - id=ShapeID("aws.protocoltests.restjson#OmitsNullSerializesEmptyString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/OmitsNullSerializesEmptyString", "method": "GET"} - ), - ) - ], -) - -OMITS_SERIALIZING_EMPTY_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OmitsSerializingEmptyListsInput"), - members={ - "queryStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="StringList") - ], - }, - "queryIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerList") - ], - }, - "queryDoubleList": { - "target": DOUBLE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="DoubleList") - ], - }, - "queryBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="BooleanList") - ], - }, - "queryTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="TimestampList") - ], - }, - "queryEnumList": { - "target": FOO_ENUM_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="EnumList")], - }, - "queryIntegerEnumList": { - "target": INTEGER_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerEnumList") - ], - }, - }, -) - -OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OmitsSerializingEmptyListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -OMITS_SERIALIZING_EMPTY_LISTS = Schema( - id=ShapeID("aws.protocoltests.restjson#OmitsSerializingEmptyLists"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/OmitsSerializingEmptyLists", "method": "POST"} - ), - ) - ], -) - -OPERATION_WITH_DEFAULTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OperationWithDefaultsInput"), - members={ - "defaults": {"target": DEFAULTS}, - "clientOptionalDefaults": {"target": CLIENT_OPTIONAL_DEFAULTS}, - "topLevelDefault": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "otherTopLevelDefault": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - }, -) - -OPERATION_WITH_DEFAULTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OperationWithDefaultsOutput"), - members={ - "defaultString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultList": { - "target": TEST_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultDocumentMap": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultDocumentString": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultDocumentBoolean": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultDocumentList": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultNullDocument": { - "target": DOCUMENT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=None)], - }, - "defaultTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "defaultBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="YWJj")], - }, - "defaultByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=10)], - }, - "defaultLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=100)], - }, - "defaultFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultMap": { - "target": TEST_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultEnum": { - "target": TEST_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="FOO")], - }, - "defaultIntEnum": { - "target": TEST_INT_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "falseBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=False)], - }, - "emptyBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "zeroByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - "zeroDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - }, -) - -OPERATION_WITH_DEFAULTS = Schema( - id=ShapeID("aws.protocoltests.restjson#OperationWithDefaults"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/OperationWithDefaults", "method": "POST"}), - ) - ], -) - -TOP_LEVEL = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TopLevel"), - members={ - "dialog": { - "target": DIALOG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "dialogList": { - "target": DIALOG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "dialogMap": { - "target": DIALOG_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - }, -) - -OPERATION_WITH_NESTED_STRUCTURE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OperationWithNestedStructureInput"), - members={ - "topLevel": { - "target": TOP_LEVEL, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -OPERATION_WITH_NESTED_STRUCTURE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OperationWithNestedStructureOutput"), - members={ - "dialog": { - "target": DIALOG, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "dialogList": { - "target": DIALOG_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "dialogMap": { - "target": DIALOG_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - }, -) - -OPERATION_WITH_NESTED_STRUCTURE = Schema( - id=ShapeID("aws.protocoltests.restjson#OperationWithNestedStructure"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/OperationWithNestedStructure", "method": "POST"} - ), - ) - ], -) - -OUTPUT_STREAM_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OutputStreamInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -OUTPUT_STREAM_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OutputStreamOutput"), - members={ - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -OUTPUT_STREAM = Schema( - id=ShapeID("aws.protocoltests.restjson#OutputStream"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"method": "POST", "uri": "/OutputStream"}), - ) - ], -) - -OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OutputStreamWithInitialResponseInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#OutputStreamWithInitialResponseOutput"), - members={ - "initialResponseMember": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="initial-response-member" - ), - Trait.new(id=ShapeID("smithy.api#required")), - ], - }, - "stream": { - "target": EVENT_STREAM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) - -OUTPUT_STREAM_WITH_INITIAL_RESPONSE = Schema( - id=ShapeID("aws.protocoltests.restjson#OutputStreamWithInitialResponse"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/OutputStreamWithInitialResponse"} - ), - ) - ], -) - -PAYLOAD_CONFIG = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PayloadConfig"), - members={"data": {"target": INTEGER}}, -) - -PLAYER_ACTION = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PlayerAction"), - shape_type=ShapeType.UNION, - members={"quit": {"target": UNIT}}, -) - -POST_PLAYER_ACTION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PostPlayerActionInput"), - members={"action": {"target": PLAYER_ACTION}}, -) - -POST_PLAYER_ACTION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PostPlayerActionOutput"), - members={ - "action": { - "target": PLAYER_ACTION, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -POST_PLAYER_ACTION = Schema( - id=ShapeID("aws.protocoltests.restjson#PostPlayerAction"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/PostPlayerAction", "method": "POST"}), - ) - ], -) - -UNION_WITH_JSON_NAME = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#UnionWithJsonName"), - shape_type=ShapeType.UNION, - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="FOO")], - }, - "bar": {"target": STRING}, - "baz": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#jsonName"), value="_baz")], - }, - }, -) - -POST_UNION_WITH_JSON_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PostUnionWithJsonNameInput"), - members={"value": {"target": UNION_WITH_JSON_NAME}}, -) - -POST_UNION_WITH_JSON_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PostUnionWithJsonNameOutput"), - members={ - "value": { - "target": UNION_WITH_JSON_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - } - }, -) - -POST_UNION_WITH_JSON_NAME = Schema( - id=ShapeID("aws.protocoltests.restjson#PostUnionWithJsonName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/PostUnionWithJsonName", "method": "POST"}), - ) - ], -) - -PUT_WITH_CONTENT_ENCODING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PutWithContentEncodingInput"), - members={ - "encoding": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Encoding") - ], - }, - "data": {"target": STRING}, - }, -) - -PUT_WITH_CONTENT_ENCODING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#PutWithContentEncodingOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -PUT_WITH_CONTENT_ENCODING = Schema( - id=ShapeID("aws.protocoltests.restjson#PutWithContentEncoding"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#requestCompression"), - value=MappingProxyType({"encodings": ("gzip",)}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/requestcompression/putcontentwithencoding"} - ), - ), - ], -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryIdempotencyTokenAutoFillInput"), - members={ - "token": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#idempotencyToken")), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="token"), - ], - } - }, -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryIdempotencyTokenAutoFillOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = Schema( - id=ShapeID("aws.protocoltests.restjson#QueryIdempotencyTokenAutoFill"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/QueryIdempotencyTokenAutoFill", "method": "POST"} - ), - ) - ], -) - -QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryParamsAsStringListMapInput"), - members={ - "qux": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="corge")], - }, - "foo": { - "target": STRING_LIST_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - }, - }, -) - -QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryParamsAsStringListMapOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_PARAMS_AS_STRING_LIST_MAP = Schema( - id=ShapeID("aws.protocoltests.restjson#QueryParamsAsStringListMap"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/StringListMap", "method": "POST"}), - ) - ], -) - -QUERY_PRECEDENCE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryPrecedenceInput"), - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="bar")], - }, - "baz": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - }, - }, -) - -QUERY_PRECEDENCE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#QueryPrecedenceOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_PRECEDENCE = Schema( - id=ShapeID("aws.protocoltests.restjson#QueryPrecedence"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/Precedence", "method": "POST"}), - ) - ], -) - -RESPONSE_CODE_HTTP_FALLBACK_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ResponseCodeHttpFallbackInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#ResponseCodeHttpFallbackInputOutput", - ) - ], -) - -RESPONSE_CODE_HTTP_FALLBACK_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ResponseCodeHttpFallbackOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#ResponseCodeHttpFallbackInputOutput", - ) - ], -) - -RESPONSE_CODE_HTTP_FALLBACK = Schema( - id=ShapeID("aws.protocoltests.restjson#ResponseCodeHttpFallback"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "GET", "uri": "/responseCodeHttpFallback", "code": 201} - ), - ) - ], -) - -RESPONSE_CODE_REQUIRED_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ResponseCodeRequiredInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -RESPONSE_CODE_REQUIRED_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#ResponseCodeRequiredOutput"), - members={ - "responseCode": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpResponseCode")), - ], - } - }, -) - -RESPONSE_CODE_REQUIRED = Schema( - id=ShapeID("aws.protocoltests.restjson#ResponseCodeRequired"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "GET", "uri": "/responseCodeRequired", "code": 200} - ), - ) - ], -) - -SIMPLE_SCALAR_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SimpleScalarPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#SimpleScalarPropertiesInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "stringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#jsonName"), value="DoubleDribble") - ], - }, - }, -) - -SIMPLE_SCALAR_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SimpleScalarPropertiesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#SimpleScalarPropertiesInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "stringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#jsonName"), value="DoubleDribble") - ], - }, - }, -) - -SIMPLE_SCALAR_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.restjson#SimpleScalarProperties"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"}), - ) - ], -) - -SPARSE_SHORT_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#SparseShortList"), - shape_type=ShapeType.LIST, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"member": {"target": SHORT}}, -) - -SPARSE_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#SparseStringList"), - shape_type=ShapeType.LIST, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"member": {"target": STRING}}, -) - -SPARSE_JSON_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseJsonListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#SparseJsonListsInputOutput", - ) - ], - members={ - "sparseStringList": {"target": SPARSE_STRING_LIST}, - "sparseShortList": {"target": SPARSE_SHORT_LIST}, - }, -) - -SPARSE_JSON_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseJsonListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#SparseJsonListsInputOutput", - ) - ], - members={ - "sparseStringList": {"target": SPARSE_STRING_LIST}, - "sparseShortList": {"target": SPARSE_SHORT_LIST}, - }, -) - -SPARSE_JSON_LISTS = Schema( - id=ShapeID("aws.protocoltests.restjson#SparseJsonLists"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/SparseJsonLists", "method": "PUT"}), - ) - ], -) - -SPARSE_BOOLEAN_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseBooleanMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": BOOLEAN}}, -) - -SPARSE_NUMBER_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseNumberMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": INTEGER}}, -) - -SPARSE_SET_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseSetMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": STRING_SET}}, -) - -SPARSE_STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#SparseStringMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -SPARSE_STRUCT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseStructMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, -) - -SPARSE_JSON_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseJsonMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#SparseJsonMapsInputOutput", - ) - ], - members={ - "sparseStructMap": {"target": SPARSE_STRUCT_MAP}, - "sparseNumberMap": {"target": SPARSE_NUMBER_MAP}, - "sparseBooleanMap": {"target": SPARSE_BOOLEAN_MAP}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - "sparseSetMap": {"target": SPARSE_SET_MAP}, - }, -) - -SPARSE_JSON_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#SparseJsonMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#SparseJsonMapsInputOutput", - ) - ], - members={ - "sparseStructMap": {"target": SPARSE_STRUCT_MAP}, - "sparseNumberMap": {"target": SPARSE_NUMBER_MAP}, - "sparseBooleanMap": {"target": SPARSE_BOOLEAN_MAP}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - "sparseSetMap": {"target": SPARSE_SET_MAP}, - }, -) - -SPARSE_JSON_MAPS = Schema( - id=ShapeID("aws.protocoltests.restjson#SparseJsonMaps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/SparseJsonMaps", "method": "POST"}), - ) - ], -) - -STREAMING_BLOB = Schema( - id=ShapeID("aws.protocoltests.restjson#StreamingBlob"), - shape_type=ShapeType.BLOB, - traits=[Trait.new(id=ShapeID("smithy.api#streaming"))], -) - -STREAMING_TRAITS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#StreamingTraitsInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": STREAMING_BLOB, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=""), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - }, -) - -STREAMING_TRAITS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#StreamingTraitsInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": STREAMING_BLOB, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=""), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - }, -) - -STREAMING_TRAITS = Schema( - id=ShapeID("aws.protocoltests.restjson#StreamingTraits"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/StreamingTraits", "method": "POST"}), - ) - ], -) - -STREAMING_TRAITS_REQUIRE_LENGTH_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsRequireLengthInput"), - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": FINITE_STREAMING_BLOB, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=""), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - }, -) - -STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsRequireLengthOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -STREAMING_TRAITS_REQUIRE_LENGTH = Schema( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsRequireLength"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/StreamingTraitsRequireLength", "method": "POST"} - ), - ) - ], -) - -STREAMING_TEXT_PLAIN_BLOB = Schema( - id=ShapeID("aws.protocoltests.restjson#StreamingTextPlainBlob"), - shape_type=ShapeType.BLOB, - traits=[ - Trait.new(id=ShapeID("smithy.api#streaming")), - Trait.new(id=ShapeID("smithy.api#mediaType"), value="text/plain"), - ], -) - -STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsWithMediaTypeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#StreamingTraitsWithMediaTypeInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": STREAMING_TEXT_PLAIN_BLOB, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=""), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - }, -) - -STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsWithMediaTypeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#StreamingTraitsWithMediaTypeInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": STREAMING_TEXT_PLAIN_BLOB, - "traits": [ - Trait.new(id=ShapeID("smithy.api#default"), value=""), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - }, - }, -) - -STREAMING_TRAITS_WITH_MEDIA_TYPE = Schema( - id=ShapeID("aws.protocoltests.restjson#StreamingTraitsWithMediaType"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/StreamingTraitsWithMediaType", "method": "POST"} - ), - ) - ], -) - -TEST_CONFIG = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestConfig"), - members={"timeout": {"target": INTEGER}}, -) - -TEST_BODY_STRUCTURE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestBodyStructureInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestBodyStructureInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-amz-test-id") - ], - }, - "testConfig": {"target": TEST_CONFIG}, - }, -) - -TEST_BODY_STRUCTURE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestBodyStructureOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestBodyStructureInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-amz-test-id") - ], - }, - "testConfig": {"target": TEST_CONFIG}, - }, -) - -TEST_BODY_STRUCTURE = Schema( - id=ShapeID("aws.protocoltests.restjson#TestBodyStructure"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/body", "method": "POST"}), - ) - ], -) - -TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestGetNoInputNoPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestGetNoInputNoPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestNoPayloadInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Test-Id") - ], - } - }, -) - -TEST_GET_NO_INPUT_NO_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#TestGetNoInputNoPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/no_input_no_payload", "method": "GET"}), - ) - ], -) - -TEST_GET_NO_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestGetNoPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestNoPayloadInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Test-Id") - ], - } - }, -) - -TEST_GET_NO_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestGetNoPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestNoPayloadInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Test-Id") - ], - } - }, -) - -TEST_GET_NO_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#TestGetNoPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/no_payload", "method": "GET"}), - ) - ], -) - -TEST_PAYLOAD_BLOB_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPayloadBlobInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestPayloadBlobInputOutput", - ) - ], - members={ - "contentType": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Type") - ], - }, - "data": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) - -TEST_PAYLOAD_BLOB_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPayloadBlobOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestPayloadBlobInputOutput", - ) - ], - members={ - "contentType": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Type") - ], - }, - "data": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) - -TEST_PAYLOAD_BLOB = Schema( - id=ShapeID("aws.protocoltests.restjson#TestPayloadBlob"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/blob_payload", "method": "POST"}), - ) - ], -) - -TEST_PAYLOAD_STRUCTURE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPayloadStructureInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestPayloadStructureInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-amz-test-id") - ], - }, - "payloadConfig": { - "target": PAYLOAD_CONFIG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) - -TEST_PAYLOAD_STRUCTURE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPayloadStructureOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestPayloadStructureInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-amz-test-id") - ], - }, - "payloadConfig": { - "target": PAYLOAD_CONFIG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) - -TEST_PAYLOAD_STRUCTURE = Schema( - id=ShapeID("aws.protocoltests.restjson#TestPayloadStructure"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/payload", "method": "POST"}), - ) - ], -) - -TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPostNoInputNoPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPostNoInputNoPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestNoPayloadInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Test-Id") - ], - } - }, -) - -TEST_POST_NO_INPUT_NO_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#TestPostNoInputNoPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/no_input_no_payload", "method": "POST"}), - ) - ], -) - -TEST_POST_NO_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPostNoPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestNoPayloadInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Test-Id") - ], - } - }, -) - -TEST_POST_NO_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TestPostNoPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TestNoPayloadInputOutput", - ) - ], - members={ - "testId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Test-Id") - ], - } - }, -) - -TEST_POST_NO_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restjson#TestPostNoPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/no_payload", "method": "POST"}), - ) - ], -) - -TIMESTAMP_FORMAT_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TimestampFormatHeadersInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TimestampFormatHeadersIO", - ) - ], - members={ - "memberEpochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberEpochSeconds" - ), - ], - }, - "memberHttpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberHttpDate" - ), - ], - }, - "memberDateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberDateTime" - ), - ], - }, - "defaultFormat": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-defaultFormat") - ], - }, - "targetEpochSeconds": { - "target": EPOCH_SECONDS, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-targetEpochSeconds" - ) - ], - }, - "targetHttpDate": { - "target": HTTP_DATE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetHttpDate") - ], - }, - "targetDateTime": { - "target": DATE_TIME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetDateTime") - ], - }, - }, -) - -TIMESTAMP_FORMAT_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#TimestampFormatHeadersOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#TimestampFormatHeadersIO", - ) - ], - members={ - "memberEpochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberEpochSeconds" - ), - ], - }, - "memberHttpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberHttpDate" - ), - ], - }, - "memberDateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberDateTime" - ), - ], - }, - "defaultFormat": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-defaultFormat") - ], - }, - "targetEpochSeconds": { - "target": EPOCH_SECONDS, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-targetEpochSeconds" - ) - ], - }, - "targetHttpDate": { - "target": HTTP_DATE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetHttpDate") - ], - }, - "targetDateTime": { - "target": DATE_TIME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetDateTime") - ], - }, - }, -) - -TIMESTAMP_FORMAT_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restjson#TimestampFormatHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/TimestampFormatHeaders", "method": "POST"} - ), - ) - ], -) - -UNIT_INPUT_AND_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#UnitInputAndOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -UNIT_INPUT_AND_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#UnitInputAndOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -UNIT_INPUT_AND_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restjson#UnitInputAndOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/UnitInputAndOutput", "method": "POST"}), - ) - ], -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#RecursiveShapesInputOutputNested1"), - members={ - "foo": {"target": STRING}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "nested": None, - }, -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#RecursiveShapesInputOutputNested2"), - members={ - "bar": {"target": STRING}, - "recursiveMember": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}, - }, -) - -RECURSIVE_SHAPES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#RecursiveShapesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#RecursiveShapesInputOutput", - ) - ], - members={"nested": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}}, -) - -RECURSIVE_SHAPES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restjson#RecursiveShapesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restjson#RecursiveShapesInputOutput", - ) - ], - members={"nested": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}}, -) - -RECURSIVE_SHAPES = Schema( - id=ShapeID("aws.protocoltests.restjson#RecursiveShapes"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/RecursiveShapes", "method": "PUT"}), - ) - ], -) - -REST_JSON = Schema( - id=ShapeID("aws.protocoltests.restjson#RestJson"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), value=MappingProxyType({"name": "restjson"}) - ), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( +TIMESTAMP_FORMAT_HEADERS = ( + 23, + n1, + _TFH, + {_s: MappingProxyType({"uri": "/TimestampFormatHeaders", "method": "POST"})}, + TIMESTAMP_FORMAT_HEADERS_INPUT, + TIMESTAMP_FORMAT_HEADERS_OUTPUT, + (), +) + +UNIT_INPUT_AND_OUTPUT_INPUT = (18, n1, _UIAOI, {_sSI: _sU}) + +UNIT_INPUT_AND_OUTPUT_OUTPUT = (18, n1, _UIAOO, {_sSI: _sU}) + +UNIT_INPUT_AND_OUTPUT = ( + 23, + n1, + _UIAO, + {_s: MappingProxyType({"uri": "/UnitInputAndOutput", "method": "POST"})}, + UNIT_INPUT_AND_OUTPUT_INPUT, + UNIT_INPUT_AND_OUTPUT_OUTPUT, + (), +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( + 18, + n1, + _RSION, + 0, + (_fo, _ne), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( + 18, + n1, + _RSIONe, + 0, + (_ba, _rM), + ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), +) + +RECURSIVE_SHAPES_INPUT = ( + 18, + n1, + _RSI, + {_sSI: _aRSIO}, + (_ne,), + ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES_OUTPUT = ( + 18, + n1, + _RSO, + {_sSI: _aRSIO}, + (_ne,), + ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES = ( + 23, + n1, + _RS, + {_s: MappingProxyType({"uri": "/RecursiveShapes", "method": "PUT"})}, + RECURSIVE_SHAPES_INPUT, + RECURSIVE_SHAPES_OUTPUT, + (), +) + +REST_JSON = ( + 21, + n1, + _RJ, + { + _aw: MappingProxyType({"name": "restjson"}), + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://restjson-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://restjson.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://restjson-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://restjson.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://restjson.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), - ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType({"sdkId": "Rest Json Protocol"}), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restjson-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restjson.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restjson-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restjson.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restjson.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - Trait.new(id=ShapeID("aws.protocols#restJson1")), - ], -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["nested"] = Schema.member( - id=RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.id.with_member("nested"), - target=RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, - index=1, + _aws: MappingProxyType({"sdkId": "Rest Json Protocol"}), + _aJ: None, + }, ) diff --git a/codegen-output/rest-json-1/src/restjson/models.py b/codegen-output/rest-json-1/src/restjson/models.py index 95a9d4c71..aab02c7e7 100644 --- a/codegen-output/rest-json-1/src/restjson/models.py +++ b/codegen-output/rest-json-1/src/restjson/models.py @@ -7,6 +7,7 @@ import logging from typing import Any, Literal, Self, Union +from smithy_core._schema_compact import hydrate from smithy_core.aio.interfaces import StreamingBlob from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import Document, TypeRegistry @@ -413,7 +414,7 @@ class ServiceError(ModeledError): def _serialize_boolean_list( serializer: ShapeSerializer, schema: Schema, value: list[bool] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_boolean(member_schema, e) @@ -423,7 +424,7 @@ def _deserialize_boolean_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[bool]: result: list[bool] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -439,7 +440,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_double_list( serializer: ShapeSerializer, schema: Schema, value: list[float] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_double(member_schema, e) @@ -449,7 +450,7 @@ def _deserialize_double_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[float]: result: list[float] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -473,7 +474,7 @@ class FooEnum(UnknownEnumMixin, StrEnum): def _serialize_foo_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -483,7 +484,7 @@ def _deserialize_foo_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -505,7 +506,7 @@ class IntegerEnum(UnknownEnumMixin, IntEnum): def _serialize_integer_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -515,7 +516,7 @@ def _deserialize_integer_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -531,7 +532,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -541,7 +542,7 @@ def _deserialize_integer_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -557,7 +558,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -567,7 +568,7 @@ def _deserialize_integer_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -583,7 +584,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -593,7 +594,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -610,7 +611,7 @@ def _serialize_string_list_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_string_list(vs, value_schema, v)) @@ -619,7 +620,7 @@ def _deserialize_string_list_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str]]: result: dict[str, list[str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -635,7 +636,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_string_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -645,7 +646,7 @@ def _deserialize_string_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -661,7 +662,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_timestamp_list( serializer: ShapeSerializer, schema: Schema, value: list[datetime] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_timestamp(member_schema, e) @@ -671,7 +672,7 @@ def _deserialize_timestamp_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[datetime]: result: list[datetime] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -731,145 +732,77 @@ class AllQueryStringTypesInput: query_params_map_of_string_list: dict[str, list[str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT).members_by_index if self.query_string is not None: - serializer.write_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryString"], - self.query_string, - ) + serializer.write_string(members[0], self.query_string) if self.query_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringList"], - self.query_string_list, - ) + _serialize_string_list(serializer, members[1], self.query_string_list) if self.query_string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringSet"], - self.query_string_set, - ) + _serialize_string_set(serializer, members[2], self.query_string_set) if self.query_byte is not None: - serializer.write_byte( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryByte"], - self.query_byte, - ) + serializer.write_byte(members[3], self.query_byte) if self.query_short is not None: - serializer.write_short( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryShort"], - self.query_short, - ) + serializer.write_short(members[4], self.query_short) if self.query_integer is not None: - serializer.write_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryInteger"], - self.query_integer, - ) + serializer.write_integer(members[5], self.query_integer) if self.query_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerList"], - self.query_integer_list, - ) + _serialize_integer_list(serializer, members[6], self.query_integer_list) if self.query_integer_set is not None: - _serialize_integer_set( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerSet"], - self.query_integer_set, - ) + _serialize_integer_set(serializer, members[7], self.query_integer_set) if self.query_long is not None: - serializer.write_long( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryLong"], - self.query_long, - ) + serializer.write_long(members[8], self.query_long) if self.query_float is not None: - serializer.write_float( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryFloat"], - self.query_float, - ) + serializer.write_float(members[9], self.query_float) if self.query_double is not None: - serializer.write_double( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDouble"], - self.query_double, - ) + serializer.write_double(members[10], self.query_double) if self.query_double_list is not None: - _serialize_double_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDoubleList"], - self.query_double_list, - ) + _serialize_double_list(serializer, members[11], self.query_double_list) if self.query_boolean is not None: - serializer.write_boolean( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryBoolean"], - self.query_boolean, - ) + serializer.write_boolean(members[12], self.query_boolean) if self.query_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryBooleanList"], - self.query_boolean_list, - ) + _serialize_boolean_list(serializer, members[13], self.query_boolean_list) if self.query_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryTimestamp"], - self.query_timestamp, - ) + serializer.write_timestamp(members[14], self.query_timestamp) if self.query_timestamp_list is not None: _serialize_timestamp_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryTimestampList"], - self.query_timestamp_list, + serializer, members[15], self.query_timestamp_list ) if self.query_enum is not None: - serializer.write_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnum"], - self.query_enum, - ) + serializer.write_string(members[16], self.query_enum) if self.query_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnumList"], - self.query_enum_list, - ) + _serialize_foo_enum_list(serializer, members[17], self.query_enum_list) if self.query_integer_enum is not None: - serializer.write_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerEnum"], - self.query_integer_enum, - ) + serializer.write_integer(members[18], self.query_integer_enum) if self.query_integer_enum_list is not None: _serialize_integer_enum_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerEnumList"], - self.query_integer_enum_list, + serializer, members[19], self.query_integer_enum_list ) if self.query_params_map_of_string_list is not None: _serialize_string_list_map( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryParamsMapOfStringList" - ], - self.query_params_map_of_string_list, + serializer, members[20], self.query_params_map_of_string_list ) @classmethod @@ -879,148 +812,98 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["query_string"] = de.read_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryString"] - ) + kwargs["query_string"] = de.read_string(members[0]) case 1: kwargs["query_string_list"] = _deserialize_string_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringList"], + de, members[1] ) case 2: - kwargs["query_string_set"] = _deserialize_string_set( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringSet"], - ) + kwargs["query_string_set"] = _deserialize_string_set(de, members[2]) case 3: - kwargs["query_byte"] = de.read_byte( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryByte"] - ) + kwargs["query_byte"] = de.read_byte(members[3]) case 4: - kwargs["query_short"] = de.read_short( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryShort"] - ) + kwargs["query_short"] = de.read_short(members[4]) case 5: - kwargs["query_integer"] = de.read_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryInteger"] - ) + kwargs["query_integer"] = de.read_integer(members[5]) case 6: kwargs["query_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryIntegerList" - ], + de, members[6] ) case 7: kwargs["query_integer_set"] = _deserialize_integer_set( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerSet"], + de, members[7] ) case 8: - kwargs["query_long"] = de.read_long( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryLong"] - ) + kwargs["query_long"] = de.read_long(members[8]) case 9: - kwargs["query_float"] = de.read_float( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryFloat"] - ) + kwargs["query_float"] = de.read_float(members[9]) case 10: - kwargs["query_double"] = de.read_double( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDouble"] - ) + kwargs["query_double"] = de.read_double(members[10]) case 11: kwargs["query_double_list"] = _deserialize_double_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDoubleList"], + de, members[11] ) case 12: - kwargs["query_boolean"] = de.read_boolean( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryBoolean"] - ) + kwargs["query_boolean"] = de.read_boolean(members[12]) case 13: kwargs["query_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryBooleanList" - ], + de, members[13] ) case 14: - kwargs["query_timestamp"] = de.read_timestamp( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryTimestamp"] - ) + kwargs["query_timestamp"] = de.read_timestamp(members[14]) case 15: kwargs["query_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryTimestampList" - ], + de, members[15] ) case 16: - kwargs["query_enum"] = FooEnum( - de.read_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnum"] - ) - ) + kwargs["query_enum"] = FooEnum(de.read_string(members[16])) case 17: kwargs["query_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnumList"], + de, members[17] ) case 18: kwargs["query_integer_enum"] = IntegerEnum( - de.read_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryIntegerEnum" - ] - ) + de.read_integer(members[18]) ) case 19: kwargs["query_integer_enum_list"] = _deserialize_integer_enum_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryIntegerEnumList" - ], + de, members[19] ) case 20: kwargs["query_params_map_of_string_list"] = ( - _deserialize_string_list_map( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryParamsMapOfStringList" - ], - ) + _deserialize_string_list_map(de, members[20]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1039,7 +922,7 @@ class AllQueryStringTypesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1051,27 +934,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ALL_QUERY_STRING_TYPES = APIOperation( input=AllQueryStringTypesInput, output=AllQueryStringTypesOutput, - schema=_SCHEMA_ALL_QUERY_STRING_TYPES, - input_schema=_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT, - output_schema=_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT, + static_schema=_SCHEMA_ALL_QUERY_STRING_TYPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1082,13 +961,12 @@ class BlobPayloadEvent: payload: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_BLOB_PAYLOAD_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_BLOB_PAYLOAD_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_BLOB_PAYLOAD_EVENT).members_by_index if self.payload is not None: - serializer.write_blob( - _SCHEMA_BLOB_PAYLOAD_EVENT.members["payload"], self.payload - ) + serializer.write_blob(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1097,18 +975,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_BLOB_PAYLOAD_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_blob( - _SCHEMA_BLOB_PAYLOAD_EVENT.members["payload"] - ) + kwargs["payload"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_BLOB_PAYLOAD_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1119,13 +997,12 @@ class ClientOptionalDefaults: member: int = 0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS, self) + serializer.write_struct(hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS).members_by_index if self.member is not None: - serializer.write_integer( - _SCHEMA_CLIENT_OPTIONAL_DEFAULTS.members["member"], self.member - ) + serializer.write_integer(members[0], self.member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1134,18 +1011,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member"] = de.read_integer( - _SCHEMA_CLIENT_OPTIONAL_DEFAULTS.members["member"] - ) + kwargs["member"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1156,13 +1033,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1171,18 +1047,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1199,23 +1075,18 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.header is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["Header"], self.header - ) + serializer.write_string(members[0], self.header) if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[1], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[2], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1224,26 +1095,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["Header"] - ) + kwargs["header"] = de.read_string(members[0]) case 1: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[1]) case 2: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1256,20 +1125,19 @@ class ConstantAndVariableQueryStringInput: maybe_set: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT + ).members_by_index if self.baz is not None: - serializer.write_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members["baz"], - self.baz, - ) + serializer.write_string(members[0], self.baz) if self.maybe_set is not None: - serializer.write_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members["maybeSet"], - self.maybe_set, - ) + serializer.write_string(members[1], self.maybe_set) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1278,27 +1146,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["baz"] = de.read_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members["baz"] - ) + kwargs["baz"] = de.read_string(members[0]) case 1: - kwargs["maybe_set"] = de.read_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members[ - "maybeSet" - ] - ) + kwargs["maybe_set"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1317,7 +1179,9 @@ class ConstantAndVariableQueryStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1329,27 +1193,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONSTANT_AND_VARIABLE_QUERY_STRING = APIOperation( input=ConstantAndVariableQueryStringInput, output=ConstantAndVariableQueryStringOutput, - schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING, - input_schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, - output_schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, + static_schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1360,13 +1220,12 @@ class ConstantQueryStringInput: hello: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_QUERY_STRING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONSTANT_QUERY_STRING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONSTANT_QUERY_STRING_INPUT).members_by_index if self.hello is not None: - serializer.write_string( - _SCHEMA_CONSTANT_QUERY_STRING_INPUT.members["hello"], self.hello - ) + serializer.write_string(members[0], self.hello) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1375,20 +1234,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_QUERY_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hello"] = de.read_string( - _SCHEMA_CONSTANT_QUERY_STRING_INPUT.members["hello"] - ) + kwargs["hello"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_QUERY_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1407,7 +1264,7 @@ class ConstantQueryStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1419,27 +1276,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_QUERY_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONSTANT_QUERY_STRING = APIOperation( input=ConstantQueryStringInput, output=ConstantQueryStringOutput, - schema=_SCHEMA_CONSTANT_QUERY_STRING, - input_schema=_SCHEMA_CONSTANT_QUERY_STRING_INPUT, - output_schema=_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT, + static_schema=_SCHEMA_CONSTANT_QUERY_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1450,13 +1303,12 @@ class ContentTypeParametersInput: value: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT).members_by_index if self.value is not None: - serializer.write_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"], self.value - ) + serializer.write_integer(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1465,20 +1317,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"] - ) + kwargs["value"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1497,7 +1347,7 @@ class ContentTypeParametersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1509,27 +1359,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONTENT_TYPE_PARAMETERS = APIOperation( input=ContentTypeParametersInput, output=ContentTypeParametersOutput, - schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, - input_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, - output_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, + static_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1538,7 +1384,7 @@ class DatetimeOffsetsInput: """Dataclass for DatetimeOffsetsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1550,13 +1396,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1577,13 +1424,12 @@ class DatetimeOffsetsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1592,30 +1438,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DATETIME_OFFSETS = APIOperation( input=DatetimeOffsetsInput, output=DatetimeOffsetsOutput, - schema=_SCHEMA_DATETIME_OFFSETS, - input_schema=_SCHEMA_DATETIME_OFFSETS_INPUT, - output_schema=_SCHEMA_DATETIME_OFFSETS_OUTPUT, + static_schema=_SCHEMA_DATETIME_OFFSETS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1633,7 +1476,7 @@ class TestIntEnum(UnknownEnumMixin, IntEnum): def _serialize_test_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -1643,7 +1486,7 @@ def _deserialize_test_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -1660,7 +1503,7 @@ def _serialize_test_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -1669,7 +1512,7 @@ def _deserialize_test_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -1743,85 +1586,38 @@ class Defaults: zero_double: float = 0.0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DEFAULTS, self) + serializer.write_struct(hydrate(_SCHEMA_DEFAULTS), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_DEFAULTS.members["defaultString"], self.default_string - ) - serializer.write_boolean( - _SCHEMA_DEFAULTS.members["defaultBoolean"], self.default_boolean - ) - _serialize_test_string_list( - serializer, _SCHEMA_DEFAULTS.members["defaultList"], self.default_list - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentMap"], self.default_document_map - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentString"], - self.default_document_string, - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentBoolean"], - self.default_document_boolean, - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultDocumentList"], self.default_document_list - ) - serializer.write_document( - _SCHEMA_DEFAULTS.members["defaultNullDocument"], self.default_null_document - ) - serializer.write_timestamp( - _SCHEMA_DEFAULTS.members["defaultTimestamp"], self.default_timestamp - ) - serializer.write_blob( - _SCHEMA_DEFAULTS.members["defaultBlob"], self.default_blob - ) - serializer.write_byte( - _SCHEMA_DEFAULTS.members["defaultByte"], self.default_byte - ) - serializer.write_short( - _SCHEMA_DEFAULTS.members["defaultShort"], self.default_short - ) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["defaultInteger"], self.default_integer - ) - serializer.write_long( - _SCHEMA_DEFAULTS.members["defaultLong"], self.default_long - ) - serializer.write_float( - _SCHEMA_DEFAULTS.members["defaultFloat"], self.default_float - ) - serializer.write_double( - _SCHEMA_DEFAULTS.members["defaultDouble"], self.default_double - ) - _serialize_test_string_map( - serializer, _SCHEMA_DEFAULTS.members["defaultMap"], self.default_map - ) - serializer.write_string( - _SCHEMA_DEFAULTS.members["defaultEnum"], self.default_enum - ) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["defaultIntEnum"], self.default_int_enum - ) - serializer.write_string( - _SCHEMA_DEFAULTS.members["emptyString"], self.empty_string - ) - serializer.write_boolean( - _SCHEMA_DEFAULTS.members["falseBoolean"], self.false_boolean - ) - serializer.write_blob(_SCHEMA_DEFAULTS.members["emptyBlob"], self.empty_blob) - serializer.write_byte(_SCHEMA_DEFAULTS.members["zeroByte"], self.zero_byte) - serializer.write_short(_SCHEMA_DEFAULTS.members["zeroShort"], self.zero_short) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["zeroInteger"], self.zero_integer - ) - serializer.write_long(_SCHEMA_DEFAULTS.members["zeroLong"], self.zero_long) - serializer.write_float(_SCHEMA_DEFAULTS.members["zeroFloat"], self.zero_float) - serializer.write_double( - _SCHEMA_DEFAULTS.members["zeroDouble"], self.zero_double - ) + members = hydrate(_SCHEMA_DEFAULTS).members_by_index + serializer.write_string(members[0], self.default_string) + serializer.write_boolean(members[1], self.default_boolean) + _serialize_test_string_list(serializer, members[2], self.default_list) + serializer.write_document(members[3], self.default_document_map) + serializer.write_document(members[4], self.default_document_string) + serializer.write_document(members[5], self.default_document_boolean) + serializer.write_document(members[6], self.default_document_list) + serializer.write_document(members[7], self.default_null_document) + serializer.write_timestamp(members[8], self.default_timestamp) + serializer.write_blob(members[9], self.default_blob) + serializer.write_byte(members[10], self.default_byte) + serializer.write_short(members[11], self.default_short) + serializer.write_integer(members[12], self.default_integer) + serializer.write_long(members[13], self.default_long) + serializer.write_float(members[14], self.default_float) + serializer.write_double(members[15], self.default_double) + _serialize_test_string_map(serializer, members[16], self.default_map) + serializer.write_string(members[17], self.default_enum) + serializer.write_integer(members[18], self.default_int_enum) + serializer.write_string(members[19], self.empty_string) + serializer.write_boolean(members[20], self.false_boolean) + serializer.write_blob(members[21], self.empty_blob) + serializer.write_byte(members[22], self.zero_byte) + serializer.write_short(members[23], self.zero_short) + serializer.write_integer(members[24], self.zero_integer) + serializer.write_long(members[25], self.zero_long) + serializer.write_float(members[26], self.zero_float) + serializer.write_double(members[27], self.zero_double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1830,153 +1626,105 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DEFAULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["default_string"] = de.read_string( - _SCHEMA_DEFAULTS.members["defaultString"] - ) + kwargs["default_string"] = de.read_string(members[0]) case 1: - kwargs["default_boolean"] = de.read_boolean( - _SCHEMA_DEFAULTS.members["defaultBoolean"] - ) + kwargs["default_boolean"] = de.read_boolean(members[1]) case 2: kwargs["default_list"] = _deserialize_test_string_list( - de, _SCHEMA_DEFAULTS.members["defaultList"] + de, members[2] ) case 3: - kwargs["default_document_map"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentMap"] - ) + kwargs["default_document_map"] = de.read_document(members[3]) case 4: - kwargs["default_document_string"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentString"] - ) + kwargs["default_document_string"] = de.read_document(members[4]) case 5: - kwargs["default_document_boolean"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentBoolean"] - ) + kwargs["default_document_boolean"] = de.read_document(members[5]) case 6: - kwargs["default_document_list"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultDocumentList"] - ) + kwargs["default_document_list"] = de.read_document(members[6]) case 7: - kwargs["default_null_document"] = de.read_document( - _SCHEMA_DEFAULTS.members["defaultNullDocument"] - ) + kwargs["default_null_document"] = de.read_document(members[7]) case 8: - kwargs["default_timestamp"] = de.read_timestamp( - _SCHEMA_DEFAULTS.members["defaultTimestamp"] - ) + kwargs["default_timestamp"] = de.read_timestamp(members[8]) case 9: - kwargs["default_blob"] = de.read_blob( - _SCHEMA_DEFAULTS.members["defaultBlob"] - ) + kwargs["default_blob"] = de.read_blob(members[9]) case 10: - kwargs["default_byte"] = de.read_byte( - _SCHEMA_DEFAULTS.members["defaultByte"] - ) + kwargs["default_byte"] = de.read_byte(members[10]) case 11: - kwargs["default_short"] = de.read_short( - _SCHEMA_DEFAULTS.members["defaultShort"] - ) + kwargs["default_short"] = de.read_short(members[11]) case 12: - kwargs["default_integer"] = de.read_integer( - _SCHEMA_DEFAULTS.members["defaultInteger"] - ) + kwargs["default_integer"] = de.read_integer(members[12]) case 13: - kwargs["default_long"] = de.read_long( - _SCHEMA_DEFAULTS.members["defaultLong"] - ) + kwargs["default_long"] = de.read_long(members[13]) case 14: - kwargs["default_float"] = de.read_float( - _SCHEMA_DEFAULTS.members["defaultFloat"] - ) + kwargs["default_float"] = de.read_float(members[14]) case 15: - kwargs["default_double"] = de.read_double( - _SCHEMA_DEFAULTS.members["defaultDouble"] - ) + kwargs["default_double"] = de.read_double(members[15]) case 16: kwargs["default_map"] = _deserialize_test_string_map( - de, _SCHEMA_DEFAULTS.members["defaultMap"] + de, members[16] ) case 17: - kwargs["default_enum"] = TestEnum( - de.read_string(_SCHEMA_DEFAULTS.members["defaultEnum"]) - ) + kwargs["default_enum"] = TestEnum(de.read_string(members[17])) case 18: kwargs["default_int_enum"] = TestIntEnum( - de.read_integer(_SCHEMA_DEFAULTS.members["defaultIntEnum"]) + de.read_integer(members[18]) ) case 19: - kwargs["empty_string"] = de.read_string( - _SCHEMA_DEFAULTS.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[19]) case 20: - kwargs["false_boolean"] = de.read_boolean( - _SCHEMA_DEFAULTS.members["falseBoolean"] - ) + kwargs["false_boolean"] = de.read_boolean(members[20]) case 21: - kwargs["empty_blob"] = de.read_blob( - _SCHEMA_DEFAULTS.members["emptyBlob"] - ) + kwargs["empty_blob"] = de.read_blob(members[21]) case 22: - kwargs["zero_byte"] = de.read_byte( - _SCHEMA_DEFAULTS.members["zeroByte"] - ) + kwargs["zero_byte"] = de.read_byte(members[22]) case 23: - kwargs["zero_short"] = de.read_short( - _SCHEMA_DEFAULTS.members["zeroShort"] - ) + kwargs["zero_short"] = de.read_short(members[23]) case 24: - kwargs["zero_integer"] = de.read_integer( - _SCHEMA_DEFAULTS.members["zeroInteger"] - ) + kwargs["zero_integer"] = de.read_integer(members[24]) case 25: - kwargs["zero_long"] = de.read_long( - _SCHEMA_DEFAULTS.members["zeroLong"] - ) + kwargs["zero_long"] = de.read_long(members[25]) case 26: - kwargs["zero_float"] = de.read_float( - _SCHEMA_DEFAULTS.members["zeroFloat"] - ) + kwargs["zero_float"] = de.read_float(members[26]) case 27: - kwargs["zero_double"] = de.read_double( - _SCHEMA_DEFAULTS.members["zeroDouble"] - ) + kwargs["zero_double"] = de.read_double(members[27]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DEFAULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1984,7 +1732,7 @@ def _serialize_dense_boolean_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, bool] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_boolean(value_schema, v)) @@ -1993,7 +1741,7 @@ def _deserialize_dense_boolean_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, bool]: result: dict[str, bool] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2010,7 +1758,7 @@ def _serialize_dense_number_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -2019,7 +1767,7 @@ def _deserialize_dense_number_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2036,7 +1784,7 @@ def _serialize_dense_set_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_string_set(vs, value_schema, v)) @@ -2045,7 +1793,7 @@ def _deserialize_dense_set_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str]]: result: dict[str, list[str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2062,7 +1810,7 @@ def _serialize_dense_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2071,7 +1819,7 @@ def _deserialize_dense_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2091,11 +1839,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2104,16 +1853,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2121,7 +1872,7 @@ def _serialize_dense_struct_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -2130,7 +1881,7 @@ def _deserialize_dense_struct_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2150,10 +1901,11 @@ class Farewell: phrase: str = "bye" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FAREWELL, self) + serializer.write_struct(hydrate(_SCHEMA_FAREWELL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_FAREWELL.members["phrase"], self.phrase) + members = hydrate(_SCHEMA_FAREWELL).members_by_index + serializer.write_string(members[0], self.phrase) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2162,18 +1914,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FAREWELL) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["phrase"] = de.read_string( - _SCHEMA_FAREWELL.members["phrase"] - ) + kwargs["phrase"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FAREWELL, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2188,15 +1940,16 @@ class Dialog: farewell: Farewell | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DIALOG, self) + serializer.write_struct(hydrate(_SCHEMA_DIALOG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DIALOG).members_by_index if self.language is not None: - serializer.write_string(_SCHEMA_DIALOG.members["language"], self.language) + serializer.write_string(members[0], self.language) - serializer.write_string(_SCHEMA_DIALOG.members["greeting"], self.greeting) + serializer.write_string(members[1], self.greeting) if self.farewell is not None: - serializer.write_struct(_SCHEMA_DIALOG.members["farewell"], self.farewell) + serializer.write_struct(members[2], self.farewell) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2205,26 +1958,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DIALOG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["language"] = de.read_string( - _SCHEMA_DIALOG.members["language"] - ) + kwargs["language"] = de.read_string(members[0]) case 1: - kwargs["greeting"] = de.read_string( - _SCHEMA_DIALOG.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[1]) case 2: kwargs["farewell"] = Farewell.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DIALOG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @classmethod @@ -2235,7 +1986,7 @@ def _smithy_default(cls) -> Self: def _serialize_dialog_list( serializer: ShapeSerializer, schema: Schema, value: list[Dialog] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2261,7 +2012,7 @@ def _serialize_dialog_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, Dialog] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -2270,7 +2021,7 @@ def _deserialize_dialog_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, Dialog]: result: dict[str, Dialog] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2292,19 +2043,15 @@ class DocumentTypeInput: document_value: Document | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_TYPE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_TYPE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_TYPE_INPUT).members_by_index if self.string_value is not None: - serializer.write_string( - _SCHEMA_DOCUMENT_TYPE_INPUT.members["stringValue"], self.string_value - ) + serializer.write_string(members[0], self.string_value) if self.document_value is not None: - serializer.write_document( - _SCHEMA_DOCUMENT_TYPE_INPUT.members["documentValue"], - self.document_value, - ) + serializer.write_document(members[1], self.document_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2313,23 +2060,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_TYPE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_value"] = de.read_string( - _SCHEMA_DOCUMENT_TYPE_INPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[0]) case 1: - kwargs["document_value"] = de.read_document( - _SCHEMA_DOCUMENT_TYPE_INPUT.members["documentValue"] - ) + kwargs["document_value"] = de.read_document(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DOCUMENT_TYPE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2352,19 +2097,15 @@ class DocumentTypeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_TYPE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_TYPE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_TYPE_OUTPUT).members_by_index if self.string_value is not None: - serializer.write_string( - _SCHEMA_DOCUMENT_TYPE_OUTPUT.members["stringValue"], self.string_value - ) + serializer.write_string(members[0], self.string_value) if self.document_value is not None: - serializer.write_document( - _SCHEMA_DOCUMENT_TYPE_OUTPUT.members["documentValue"], - self.document_value, - ) + serializer.write_document(members[1], self.document_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2373,35 +2114,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_TYPE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_value"] = de.read_string( - _SCHEMA_DOCUMENT_TYPE_OUTPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[0]) case 1: - kwargs["document_value"] = de.read_document( - _SCHEMA_DOCUMENT_TYPE_OUTPUT.members["documentValue"] - ) + kwargs["document_value"] = de.read_document(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DOCUMENT_TYPE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DOCUMENT_TYPE = APIOperation( input=DocumentTypeInput, output=DocumentTypeOutput, - schema=_SCHEMA_DOCUMENT_TYPE, - input_schema=_SCHEMA_DOCUMENT_TYPE_INPUT, - output_schema=_SCHEMA_DOCUMENT_TYPE_OUTPUT, + static_schema=_SCHEMA_DOCUMENT_TYPE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2409,7 +2145,7 @@ def _serialize_document_valued_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, Document] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_document(value_schema, v)) @@ -2418,7 +2154,7 @@ def _deserialize_document_valued_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, Document]: result: dict[str, Document] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2438,15 +2174,12 @@ class DocumentTypeAsMapValueInput: doc_valued_map: dict[str, Document] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT).members_by_index if self.doc_valued_map is not None: - _serialize_document_valued_map( - serializer, - _SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT.members["docValuedMap"], - self.doc_valued_map, - ) + _serialize_document_valued_map(serializer, members[0], self.doc_valued_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2455,23 +2188,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["doc_valued_map"] = _deserialize_document_valued_map( - de, - _SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT.members[ - "docValuedMap" - ], + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2492,15 +2222,14 @@ class DocumentTypeAsMapValueOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT).members_by_index if self.doc_valued_map is not None: - _serialize_document_valued_map( - serializer, - _SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT.members["docValuedMap"], - self.doc_valued_map, - ) + _serialize_document_valued_map(serializer, members[0], self.doc_valued_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2509,35 +2238,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["doc_valued_map"] = _deserialize_document_valued_map( - de, - _SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT.members[ - "docValuedMap" - ], + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DOCUMENT_TYPE_AS_MAP_VALUE = APIOperation( input=DocumentTypeAsMapValueInput, output=DocumentTypeAsMapValueOutput, - schema=_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE, - input_schema=_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_INPUT, - output_schema=_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT, + static_schema=_SCHEMA_DOCUMENT_TYPE_AS_MAP_VALUE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2548,14 +2271,12 @@ class DocumentTypeAsPayloadInput: document_value: Document | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT).members_by_index if self.document_value is not None: - serializer.write_document( - _SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT.members["documentValue"], - self.document_value, - ) + serializer.write_document(members[0], self.document_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2564,20 +2285,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["document_value"] = de.read_document( - _SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT.members["documentValue"] - ) + kwargs["document_value"] = de.read_document(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2598,14 +2317,12 @@ class DocumentTypeAsPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT).members_by_index if self.document_value is not None: - serializer.write_document( - _SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT.members["documentValue"], - self.document_value, - ) + serializer.write_document(members[0], self.document_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2614,32 +2331,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["document_value"] = de.read_document( - _SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT.members["documentValue"] - ) + kwargs["document_value"] = de.read_document(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DOCUMENT_TYPE_AS_PAYLOAD = APIOperation( input=DocumentTypeAsPayloadInput, output=DocumentTypeAsPayloadOutput, - schema=_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD, - input_schema=_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_INPUT, - output_schema=_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_DOCUMENT_TYPE_AS_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2650,13 +2362,12 @@ class ErrorEvent(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ERROR_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_ERROR_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_ERROR_EVENT).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_ERROR_EVENT.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2665,18 +2376,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ERROR_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_ERROR_EVENT.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ERROR_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2701,48 +2412,33 @@ class HeadersEvent: timestamp_header: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HEADERS_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_HEADERS_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HEADERS_EVENT).members_by_index if self.boolean_header is not None: - serializer.write_boolean( - _SCHEMA_HEADERS_EVENT.members["booleanHeader"], self.boolean_header - ) + serializer.write_boolean(members[0], self.boolean_header) if self.byte_header is not None: - serializer.write_byte( - _SCHEMA_HEADERS_EVENT.members["byteHeader"], self.byte_header - ) + serializer.write_byte(members[1], self.byte_header) if self.short_header is not None: - serializer.write_short( - _SCHEMA_HEADERS_EVENT.members["shortHeader"], self.short_header - ) + serializer.write_short(members[2], self.short_header) if self.int_header is not None: - serializer.write_integer( - _SCHEMA_HEADERS_EVENT.members["intHeader"], self.int_header - ) + serializer.write_integer(members[3], self.int_header) if self.long_header is not None: - serializer.write_long( - _SCHEMA_HEADERS_EVENT.members["longHeader"], self.long_header - ) + serializer.write_long(members[4], self.long_header) if self.blob_header is not None: - serializer.write_blob( - _SCHEMA_HEADERS_EVENT.members["blobHeader"], self.blob_header - ) + serializer.write_blob(members[5], self.blob_header) if self.string_header is not None: - serializer.write_string( - _SCHEMA_HEADERS_EVENT.members["stringHeader"], self.string_header - ) + serializer.write_string(members[6], self.string_header) if self.timestamp_header is not None: - serializer.write_timestamp( - _SCHEMA_HEADERS_EVENT.members["timestampHeader"], self.timestamp_header - ) + serializer.write_timestamp(members[7], self.timestamp_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2751,53 +2447,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HEADERS_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["boolean_header"] = de.read_boolean( - _SCHEMA_HEADERS_EVENT.members["booleanHeader"] - ) + kwargs["boolean_header"] = de.read_boolean(members[0]) case 1: - kwargs["byte_header"] = de.read_byte( - _SCHEMA_HEADERS_EVENT.members["byteHeader"] - ) + kwargs["byte_header"] = de.read_byte(members[1]) case 2: - kwargs["short_header"] = de.read_short( - _SCHEMA_HEADERS_EVENT.members["shortHeader"] - ) + kwargs["short_header"] = de.read_short(members[2]) case 3: - kwargs["int_header"] = de.read_integer( - _SCHEMA_HEADERS_EVENT.members["intHeader"] - ) + kwargs["int_header"] = de.read_integer(members[3]) case 4: - kwargs["long_header"] = de.read_long( - _SCHEMA_HEADERS_EVENT.members["longHeader"] - ) + kwargs["long_header"] = de.read_long(members[4]) case 5: - kwargs["blob_header"] = de.read_blob( - _SCHEMA_HEADERS_EVENT.members["blobHeader"] - ) + kwargs["blob_header"] = de.read_blob(members[5]) case 6: - kwargs["string_header"] = de.read_string( - _SCHEMA_HEADERS_EVENT.members["stringHeader"] - ) + kwargs["string_header"] = de.read_string(members[6]) case 7: - kwargs["timestamp_header"] = de.read_timestamp( - _SCHEMA_HEADERS_EVENT.members["timestampHeader"] - ) + kwargs["timestamp_header"] = de.read_timestamp(members[7]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HEADERS_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2808,14 +2490,12 @@ class PayloadStructure: structure_member: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_STRUCTURE, self) + serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_STRUCTURE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PAYLOAD_STRUCTURE).members_by_index if self.structure_member is not None: - serializer.write_string( - _SCHEMA_PAYLOAD_STRUCTURE.members["structureMember"], - self.structure_member, - ) + serializer.write_string(members[0], self.structure_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2824,18 +2504,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PAYLOAD_STRUCTURE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["structure_member"] = de.read_string( - _SCHEMA_PAYLOAD_STRUCTURE.members["structureMember"] - ) + kwargs["structure_member"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PAYLOAD_STRUCTURE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2848,20 +2528,17 @@ class HeadersAndExplicitPayloadEvent: payload: PayloadStructure | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT, self) + serializer.write_struct( + hydrate(_SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT).members_by_index if self.header is not None: - serializer.write_string( - _SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT.members["header"], - self.header, - ) + serializer.write_string(members[0], self.header) if self.payload is not None: - serializer.write_struct( - _SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT.members["payload"], - self.payload, - ) + serializer.write_struct(members[1], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2870,23 +2547,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header"] = de.read_string( - _SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT.members["header"] - ) + kwargs["header"] = de.read_string(members[0]) case 1: kwargs["payload"] = PayloadStructure.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HEADERS_AND_EXPLICIT_PAYLOAD_EVENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2899,20 +2574,17 @@ class HeadersAndImplicitPayloadEvent: payload: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT, self) + serializer.write_struct( + hydrate(_SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT).members_by_index if self.header is not None: - serializer.write_string( - _SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT.members["header"], - self.header, - ) + serializer.write_string(members[0], self.header) if self.payload is not None: - serializer.write_string( - _SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT.members["payload"], - self.payload, - ) + serializer.write_string(members[1], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2921,25 +2593,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header"] = de.read_string( - _SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT.members["header"] - ) + kwargs["header"] = de.read_string(members[0]) case 1: - kwargs["payload"] = de.read_string( - _SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT.members["payload"] - ) + kwargs["payload"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HEADERS_AND_IMPLICIT_PAYLOAD_EVENT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2950,13 +2618,12 @@ class StringPayloadEvent: payload: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRING_PAYLOAD_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_STRING_PAYLOAD_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRING_PAYLOAD_EVENT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_STRING_PAYLOAD_EVENT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2965,18 +2632,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRING_PAYLOAD_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_STRING_PAYLOAD_EVENT.members["payload"] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRING_PAYLOAD_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2987,13 +2654,12 @@ class StructurePayloadEvent: payload: PayloadStructure | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCTURE_PAYLOAD_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCTURE_PAYLOAD_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCTURE_PAYLOAD_EVENT).members_by_index if self.payload is not None: - serializer.write_struct( - _SCHEMA_STRUCTURE_PAYLOAD_EVENT.members["payload"], self.payload - ) + serializer.write_struct(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3002,16 +2668,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCTURE_PAYLOAD_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["payload"] = PayloadStructure.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCTURE_PAYLOAD_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3020,18 +2688,16 @@ class PayloadUnionUnionMember: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_PAYLOAD_UNION.members["unionMember"], self.value - ) + members = hydrate(_SCHEMA_PAYLOAD_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_PAYLOAD_UNION.members["unionMember"]) - ) + members = hydrate(_SCHEMA_PAYLOAD_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -3066,7 +2732,7 @@ class _PayloadUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> PayloadUnion: self._result = None - deserializer.read_struct(_SCHEMA_PAYLOAD_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_PAYLOAD_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -3098,13 +2764,12 @@ class UnionPayloadEvent: payload: PayloadUnion | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNION_PAYLOAD_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_UNION_PAYLOAD_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_UNION_PAYLOAD_EVENT).members_by_index if self.payload is not None: - serializer.write_struct( - _SCHEMA_UNION_PAYLOAD_EVENT.members["payload"], self.payload - ) + serializer.write_struct(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3113,16 +2778,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_UNION_PAYLOAD_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["payload"] = _PayloadUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_UNION_PAYLOAD_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3131,10 +2798,11 @@ class EventStreamHeaders: value: HeadersEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM.members["headers"], self.value) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3146,10 +2814,11 @@ class EventStreamBlobPayload: value: BlobPayloadEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM.members["blobPayload"], self.value) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3161,12 +2830,11 @@ class EventStreamStringPayload: value: StringPayloadEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_EVENT_STREAM.members["stringPayload"], self.value - ) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3178,12 +2846,11 @@ class EventStreamStructurePayload: value: StructurePayloadEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_EVENT_STREAM.members["structurePayload"], self.value - ) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3195,12 +2862,11 @@ class EventStreamUnionPayload: value: UnionPayloadEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_EVENT_STREAM.members["unionPayload"], self.value - ) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3212,12 +2878,11 @@ class EventStreamHeadersAndExplicitPayload: value: HeadersAndExplicitPayloadEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_EVENT_STREAM.members["headersAndExplicitPayload"], self.value - ) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3229,12 +2894,11 @@ class EventStreamHeadersAndImplicitPayload: value: HeadersAndImplicitPayloadEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_EVENT_STREAM.members["headersAndImplicitPayload"], self.value - ) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3246,10 +2910,11 @@ class EventStreamError: value: ErrorEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EVENT_STREAM.members["error"], self.value) + members = hydrate(_SCHEMA_EVENT_STREAM).members_by_index + serializer.write_struct(members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3298,7 +2963,7 @@ class _EventStreamDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> EventStream: self._result = None - deserializer.read_struct(_SCHEMA_EVENT_STREAM, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_EVENT_STREAM), self._consumer) if self._result is None: raise SerializationError( @@ -3349,7 +3014,7 @@ class DuplexStreamInput: """Dataclass for DuplexStreamInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DUPLEX_STREAM_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DUPLEX_STREAM_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3361,13 +3026,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DUPLEX_STREAM_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DUPLEX_STREAM_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3386,7 +3052,7 @@ class DuplexStreamOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DUPLEX_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DUPLEX_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3398,25 +3064,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DUPLEX_STREAM_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DUPLEX_STREAM_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DUPLEX_STREAM = APIOperation( input=DuplexStreamInput, output=DuplexStreamOutput, - schema=_SCHEMA_DUPLEX_STREAM, - input_schema=_SCHEMA_DUPLEX_STREAM_INPUT, - output_schema=_SCHEMA_DUPLEX_STREAM_OUTPUT, + static_schema=_SCHEMA_DUPLEX_STREAM, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3425,7 +3089,9 @@ class DuplexStreamWithDistinctStreamsInput: """Dataclass for DuplexStreamWithDistinctStreamsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3437,15 +3103,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3456,13 +3121,12 @@ class SingletonEvent: value: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SINGLETON_EVENT, self) + serializer.write_struct(hydrate(_SCHEMA_SINGLETON_EVENT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SINGLETON_EVENT).members_by_index if self.value is not None: - serializer.write_string( - _SCHEMA_SINGLETON_EVENT.members["value"], self.value - ) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3471,18 +3135,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SINGLETON_EVENT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_SINGLETON_EVENT.members["value"] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SINGLETON_EVENT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3491,12 +3155,11 @@ class SingletonEventStreamSingleton: value: SingletonEvent def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SINGLETON_EVENT_STREAM, self) + serializer.write_struct(hydrate(_SCHEMA_SINGLETON_EVENT_STREAM), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_SINGLETON_EVENT_STREAM.members["singleton"], self.value - ) + members = hydrate(_SCHEMA_SINGLETON_EVENT_STREAM).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3537,7 +3200,9 @@ class _SingletonEventStreamDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> SingletonEventStream: self._result = None - deserializer.read_struct(_SCHEMA_SINGLETON_EVENT_STREAM, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_SINGLETON_EVENT_STREAM), self._consumer + ) if self._result is None: raise SerializationError( @@ -3582,15 +3247,15 @@ class DuplexStreamWithDistinctStreamsOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT, self + hydrate(_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT + ).members_by_index if self.stream is not None: - serializer.write_struct( - _SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT.members["stream"], - self.stream, - ) + serializer.write_struct(members[0], self.stream) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3599,32 +3264,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["stream"] = _SingletonEventStreamDeserializer().deserialize( de ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DUPLEX_STREAM_WITH_DISTINCT_STREAMS = APIOperation( input=DuplexStreamWithDistinctStreamsInput, output=DuplexStreamWithDistinctStreamsOutput, - schema=_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS, - input_schema=_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT, - output_schema=_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT, + static_schema=_SCHEMA_DUPLEX_STREAM_WITH_DISTINCT_STREAMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3635,16 +3297,16 @@ class DuplexStreamWithInitialMessagesInput: initial_request_member: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT + ).members_by_index if self.initial_request_member is not None: - serializer.write_string( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT.members[ - "initialRequestMember" - ], - self.initial_request_member, - ) + serializer.write_string(members[0], self.initial_request_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3653,22 +3315,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["initial_request_member"] = de.read_string( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT.members[ - "initialRequestMember" - ] - ) + kwargs["initial_request_member"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3690,16 +3348,14 @@ class DuplexStreamWithInitialMessagesOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT, self + hydrate(_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT.members[ - "initialResponseMember" - ], - self.initial_response_member, - ) + members = hydrate( + _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT + ).members_by_index + serializer.write_string(members[0], self.initial_response_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3708,22 +3364,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["initial_response_member"] = de.read_string( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT.members[ - "initialResponseMember" - ] - ) + kwargs["initial_response_member"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "initial_response_member" not in kwargs: kwargs["initial_response_member"] = "" return kwargs @@ -3736,13 +3388,12 @@ class ServiceUnavailableError(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SERVICE_UNAVAILABLE_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_SERVICE_UNAVAILABLE_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SERVICE_UNAVAILABLE_ERROR).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_SERVICE_UNAVAILABLE_ERROR.members["message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3751,27 +3402,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SERVICE_UNAVAILABLE_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_SERVICE_UNAVAILABLE_ERROR.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SERVICE_UNAVAILABLE_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DUPLEX_STREAM_WITH_INITIAL_MESSAGES = APIOperation( input=DuplexStreamWithInitialMessagesInput, output=DuplexStreamWithInitialMessagesOutput, - schema=_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES, - input_schema=_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT, - output_schema=_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT, + static_schema=_SCHEMA_DUPLEX_STREAM_WITH_INITIAL_MESSAGES, error_registry=TypeRegistry( { ShapeID( @@ -3780,7 +3429,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_SERVICE_UNAVAILABLE_ERROR], ) @@ -3789,7 +3437,9 @@ class EmptyInputAndEmptyOutputInput: """Dataclass for EmptyInputAndEmptyOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3801,15 +3451,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3828,7 +3477,9 @@ class EmptyInputAndEmptyOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3840,27 +3491,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_INPUT_AND_EMPTY_OUTPUT = APIOperation( input=EmptyInputAndEmptyOutputInput, output=EmptyInputAndEmptyOutputOutput, - schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, - input_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, - output_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + static_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3869,7 +3516,7 @@ class EndpointOperationInput: """Dataclass for EndpointOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3881,13 +3528,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3906,7 +3554,7 @@ class EndpointOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3918,25 +3566,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_OPERATION = APIOperation( input=EndpointOperationInput, output=EndpointOperationOutput, - schema=_SCHEMA_ENDPOINT_OPERATION, - input_schema=_SCHEMA_ENDPOINT_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3947,14 +3593,16 @@ class EndpointWithHostLabelOperationInput: label: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT + ).members_by_index if self.label is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members["label"], - self.label, - ) + serializer.write_string(members[0], self.label) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3963,22 +3611,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["label"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members[ - "label" - ] - ) + kwargs["label"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3997,7 +3641,9 @@ class EndpointWithHostLabelOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4009,27 +3655,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_OPERATION = APIOperation( input=EndpointWithHostLabelOperationInput, output=EndpointWithHostLabelOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4043,7 +3685,7 @@ class FooError(ServiceError): fault: Literal["client", "server"] | None = "server" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FOO_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_FOO_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4055,13 +3697,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FOO_ERROR) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FOO_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4070,7 +3713,7 @@ class FractionalSecondsInput: """Dataclass for FractionalSecondsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4082,13 +3725,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4109,13 +3753,12 @@ class FractionalSecondsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4124,30 +3767,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FRACTIONAL_SECONDS = APIOperation( input=FractionalSecondsInput, output=FractionalSecondsOutput, - schema=_SCHEMA_FRACTIONAL_SECONDS, - input_schema=_SCHEMA_FRACTIONAL_SECONDS_INPUT, - output_schema=_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, + static_schema=_SCHEMA_FRACTIONAL_SECONDS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4156,7 +3796,7 @@ class GreetingWithErrorsInput: """Dataclass for GreetingWithErrorsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4168,13 +3808,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4195,13 +3836,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4210,20 +3850,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4234,13 +3872,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4249,27 +3886,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.restjson#InvalidGreeting"): InvalidGreeting, @@ -4278,7 +3913,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_INVALID_GREETING, _SCHEMA_COMPLEX_ERROR, _SCHEMA_FOO_ERROR], ) @@ -4287,7 +3921,7 @@ class HostWithPathOperationInput: """Dataclass for HostWithPathOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4299,15 +3933,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4326,7 +3959,7 @@ class HostWithPathOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4338,27 +3971,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HOST_WITH_PATH_OPERATION = APIOperation( input=HostWithPathOperationInput, output=HostWithPathOperationOutput, - schema=_SCHEMA_HOST_WITH_PATH_OPERATION, - input_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_INPUT, - output_schema=_SCHEMA_HOST_WITH_PATH_OPERATION_OUTPUT, + static_schema=_SCHEMA_HOST_WITH_PATH_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4369,13 +3998,12 @@ class HttpChecksumRequiredInput: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4384,20 +4012,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4418,13 +4044,12 @@ class HttpChecksumRequiredOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4433,32 +4058,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_CHECKSUM_REQUIRED = APIOperation( input=HttpChecksumRequiredInput, output=HttpChecksumRequiredOutput, - schema=_SCHEMA_HTTP_CHECKSUM_REQUIRED, - input_schema=_SCHEMA_HTTP_CHECKSUM_REQUIRED_INPUT, - output_schema=_SCHEMA_HTTP_CHECKSUM_REQUIRED_OUTPUT, + static_schema=_SCHEMA_HTTP_CHECKSUM_REQUIRED, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4466,7 +4086,7 @@ def _serialize_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -4475,7 +4095,7 @@ def _deserialize_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -4497,21 +4117,15 @@ class HttpEmptyPrefixHeadersInput: specific_header: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT).members_by_index if self.prefix_headers is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members["prefixHeaders"], - self.prefix_headers, - ) + _serialize_string_map(serializer, members[0], self.prefix_headers) if self.specific_header is not None: - serializer.write_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members["specificHeader"], - self.specific_header, - ) + serializer.write_string(members[1], self.specific_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4520,30 +4134,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["prefix_headers"] = _deserialize_string_map( - de, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members[ - "prefixHeaders" - ], - ) + kwargs["prefix_headers"] = _deserialize_string_map(de, members[0]) case 1: - kwargs["specific_header"] = de.read_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members[ - "specificHeader" - ] - ) + kwargs["specific_header"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4566,21 +4171,15 @@ class HttpEmptyPrefixHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT).members_by_index if self.prefix_headers is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members["prefixHeaders"], - self.prefix_headers, - ) + _serialize_string_map(serializer, members[0], self.prefix_headers) if self.specific_header is not None: - serializer.write_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members["specificHeader"], - self.specific_header, - ) + serializer.write_string(members[1], self.specific_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4589,42 +4188,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["prefix_headers"] = _deserialize_string_map( - de, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members[ - "prefixHeaders" - ], - ) + kwargs["prefix_headers"] = _deserialize_string_map(de, members[0]) case 1: - kwargs["specific_header"] = de.read_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members[ - "specificHeader" - ] - ) + kwargs["specific_header"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_EMPTY_PREFIX_HEADERS = APIOperation( input=HttpEmptyPrefixHeadersInput, output=HttpEmptyPrefixHeadersOutput, - schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS, - input_schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT, - output_schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, + static_schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4639,13 +4226,12 @@ class HttpEnumPayloadInput: payload: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_INPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4654,20 +4240,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = StringEnum( - de.read_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_INPUT.members["payload"] - ) - ) + kwargs["payload"] = StringEnum(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4688,13 +4272,12 @@ class HttpEnumPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4703,32 +4286,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = StringEnum( - de.read_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT.members["payload"] - ) - ) + kwargs["payload"] = StringEnum(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_ENUM_PAYLOAD = APIOperation( input=HttpEnumPayloadInput, output=HttpEnumPayloadOutput, - schema=_SCHEMA_HTTP_ENUM_PAYLOAD, - input_schema=_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT, - output_schema=_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_HTTP_ENUM_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4741,18 +4319,15 @@ class HttpPayloadTraitsInput: blob: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["blob"], self.blob - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4761,23 +4336,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4800,18 +4373,15 @@ class HttpPayloadTraitsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["blob"], self.blob - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4820,35 +4390,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["blob"] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_TRAITS = APIOperation( input=HttpPayloadTraitsInput, output=HttpPayloadTraitsOutput, - schema=_SCHEMA_HTTP_PAYLOAD_TRAITS, - input_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4861,20 +4426,19 @@ class HttpPayloadTraitsWithMediaTypeInput: blob: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members["blob"], - self.blob, - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4883,27 +4447,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members[ - "blob" - ] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4927,21 +4485,18 @@ class HttpPayloadTraitsWithMediaTypeOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, self + hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["blob"], - self.blob, - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4950,41 +4505,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members[ - "foo" - ] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members[ - "blob" - ] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = APIOperation( input=HttpPayloadTraitsWithMediaTypeInput, output=HttpPayloadTraitsWithMediaTypeOutput, - schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, - input_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4997,16 +4541,15 @@ class NestedPayload: name: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_PAYLOAD, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_PAYLOAD), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_PAYLOAD).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_NESTED_PAYLOAD.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) if self.name is not None: - serializer.write_string(_SCHEMA_NESTED_PAYLOAD.members["name"], self.name) + serializer.write_string(members[1], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5015,23 +4558,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_PAYLOAD) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_NESTED_PAYLOAD.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_NESTED_PAYLOAD.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_PAYLOAD, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5042,13 +4583,14 @@ class HttpPayloadWithStructureInput: nested: NestedPayload | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5057,18 +4599,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = NestedPayload.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5089,14 +4631,14 @@ class HttpPayloadWithStructureOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT.members["nested"], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5105,30 +4647,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = NestedPayload.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_STRUCTURE = APIOperation( input=HttpPayloadWithStructureInput, output=HttpPayloadWithStructureOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5137,16 +4676,16 @@ class UnionPayloadGreeting: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNION_PAYLOAD, self) + serializer.write_struct(hydrate(_SCHEMA_UNION_PAYLOAD), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_UNION_PAYLOAD.members["greeting"], self.value) + members = hydrate(_SCHEMA_UNION_PAYLOAD).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_UNION_PAYLOAD.members["greeting"]) - ) + members = hydrate(_SCHEMA_UNION_PAYLOAD).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -5181,7 +4720,7 @@ class _UnionPayloadDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> UnionPayload: self._result = None - deserializer.read_struct(_SCHEMA_UNION_PAYLOAD, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_UNION_PAYLOAD), self._consumer) if self._result is None: raise SerializationError( @@ -5213,13 +4752,12 @@ class HttpPayloadWithUnionInput: nested: UnionPayload | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5228,18 +4766,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = _UnionPayloadDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5260,13 +4798,12 @@ class HttpPayloadWithUnionOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5275,30 +4812,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = _UnionPayloadDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_UNION = APIOperation( input=HttpPayloadWithUnionInput, output=HttpPayloadWithUnionOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5311,20 +4845,15 @@ class HttpPrefixHeadersInput: foo_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.foo_map is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["fooMap"], - self.foo_map, - ) + _serialize_string_map(serializer, members[1], self.foo_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5333,23 +4862,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["foo_map"] = _deserialize_string_map( - de, _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["fooMap"] - ) + kwargs["foo_map"] = _deserialize_string_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5372,20 +4899,15 @@ class HttpPrefixHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.foo_map is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["fooMap"], - self.foo_map, - ) + _serialize_string_map(serializer, members[1], self.foo_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5394,35 +4916,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["foo_map"] = _deserialize_string_map( - de, _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["fooMap"] - ) + kwargs["foo_map"] = _deserialize_string_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PREFIX_HEADERS = APIOperation( input=HttpPrefixHeadersInput, output=HttpPrefixHeadersOutput, - schema=_SCHEMA_HTTP_PREFIX_HEADERS, - input_schema=_SCHEMA_HTTP_PREFIX_HEADERS_INPUT, - output_schema=_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT, + static_schema=_SCHEMA_HTTP_PREFIX_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5431,7 +4948,9 @@ class HttpPrefixHeadersInResponseInput: """Dataclass for HttpPrefixHeadersInResponseInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5443,15 +4962,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5472,15 +4990,16 @@ class HttpPrefixHeadersInResponseOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT + ).members_by_index if self.prefix_headers is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT.members["prefixHeaders"], - self.prefix_headers, - ) + _serialize_string_map(serializer, members[0], self.prefix_headers) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5489,35 +5008,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["prefix_headers"] = _deserialize_string_map( - de, - _SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT.members[ - "prefixHeaders" - ], - ) + kwargs["prefix_headers"] = _deserialize_string_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PREFIX_HEADERS_IN_RESPONSE = APIOperation( input=HttpPrefixHeadersInResponseInput, output=HttpPrefixHeadersInResponseOutput, - schema=_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE, - input_schema=_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT, - output_schema=_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT, + static_schema=_SCHEMA_HTTP_PREFIX_HEADERS_IN_RESPONSE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5525,7 +5036,7 @@ def _serialize_query_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -5534,7 +5045,7 @@ def _deserialize_query_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -5554,15 +5065,16 @@ class HttpQueryParamsOnlyOperationInput: query_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT + ).members_by_index if self.query_map is not None: - _serialize_query_map( - serializer, - _SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT.members["queryMap"], - self.query_map, - ) + _serialize_query_map(serializer, members[0], self.query_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5571,23 +5083,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["query_map"] = _deserialize_query_map( - de, - _SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT.members[ - "queryMap" - ], - ) + kwargs["query_map"] = _deserialize_query_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5606,7 +5113,9 @@ class HttpQueryParamsOnlyOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5618,27 +5127,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_QUERY_PARAMS_ONLY_OPERATION = APIOperation( input=HttpQueryParamsOnlyOperationInput, output=HttpQueryParamsOnlyOperationOutput, - schema=_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION, - input_schema=_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT, - output_schema=_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT, + static_schema=_SCHEMA_HTTP_QUERY_PARAMS_ONLY_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5651,20 +5156,17 @@ class HttpRequestWithFloatLabelsInput: double: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT).members_by_index if self.float_ is not None: - serializer.write_float( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["float"], - self.float_, - ) + serializer.write_float(members[0], self.float_) if self.double is not None: - serializer.write_double( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["double"], - self.double, - ) + serializer.write_double(members[1], self.double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5673,25 +5175,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_"] = de.read_float( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["float"] - ) + kwargs["float_"] = de.read_float(members[0]) case 1: - kwargs["double"] = de.read_double( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["double"] - ) + kwargs["double"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5710,7 +5208,9 @@ class HttpRequestWithFloatLabelsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5722,27 +5222,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_FLOAT_LABELS = APIOperation( input=HttpRequestWithFloatLabelsInput, output=HttpRequestWithFloatLabelsOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5756,21 +5252,18 @@ class HttpRequestWithGreedyLabelInPathInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.baz is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members["baz"], - self.baz, - ) + serializer.write_string(members[1], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5779,29 +5272,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members[ - "foo" - ] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["baz"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members[ - "baz" - ] - ) + kwargs["baz"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5821,7 +5306,7 @@ class HttpRequestWithGreedyLabelInPathOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -5834,27 +5319,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = APIOperation( input=HttpRequestWithGreedyLabelInPathInput, output=HttpRequestWithGreedyLabelInPathOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5884,49 +5365,33 @@ class HttpRequestWithLabelsInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT).members_by_index if self.string is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["string"], self.string - ) + serializer.write_string(members[0], self.string) if self.short is not None: - serializer.write_short( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["short"], self.short - ) + serializer.write_short(members[1], self.short) if self.integer is not None: - serializer.write_integer( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["integer"], self.integer - ) + serializer.write_integer(members[2], self.integer) if self.long is not None: - serializer.write_long( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["long"], self.long - ) + serializer.write_long(members[3], self.long) if self.float_ is not None: - serializer.write_float( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["float"], self.float_ - ) + serializer.write_float(members[4], self.float_) if self.double is not None: - serializer.write_double( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["double"], self.double - ) + serializer.write_double(members[5], self.double) if self.boolean is not None: - serializer.write_boolean( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["boolean"], self.boolean - ) + serializer.write_boolean(members[6], self.boolean) if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[7], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5935,55 +5400,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["string"] - ) + kwargs["string"] = de.read_string(members[0]) case 1: - kwargs["short"] = de.read_short( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["short"] - ) + kwargs["short"] = de.read_short(members[1]) case 2: - kwargs["integer"] = de.read_integer( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["integer"] - ) + kwargs["integer"] = de.read_integer(members[2]) case 3: - kwargs["long"] = de.read_long( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["long"] - ) + kwargs["long"] = de.read_long(members[3]) case 4: - kwargs["float_"] = de.read_float( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["float"] - ) + kwargs["float_"] = de.read_float(members[4]) case 5: - kwargs["double"] = de.read_double( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["double"] - ) + kwargs["double"] = de.read_double(members[5]) case 6: - kwargs["boolean"] = de.read_boolean( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["boolean"] - ) + kwargs["boolean"] = de.read_boolean(members[6]) case 7: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["timestamp"] - ) + kwargs["timestamp"] = de.read_timestamp(members[7]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6002,7 +5451,7 @@ class HttpRequestWithLabelsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6014,27 +5463,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_LABELS = APIOperation( input=HttpRequestWithLabelsInput, output=HttpRequestWithLabelsOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6058,65 +5503,33 @@ class HttpRequestWithLabelsAndTimestampFormatInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT + ).members_by_index if self.member_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberEpochSeconds" - ], - self.member_epoch_seconds, - ) + serializer.write_timestamp(members[0], self.member_epoch_seconds) if self.member_http_date is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberHttpDate" - ], - self.member_http_date, - ) + serializer.write_timestamp(members[1], self.member_http_date) if self.member_date_time is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberDateTime" - ], - self.member_date_time, - ) + serializer.write_timestamp(members[2], self.member_date_time) if self.default_format is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "defaultFormat" - ], - self.default_format, - ) + serializer.write_timestamp(members[3], self.default_format) if self.target_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetEpochSeconds" - ], - self.target_epoch_seconds, - ) + serializer.write_timestamp(members[4], self.target_epoch_seconds) if self.target_http_date is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetHttpDate" - ], - self.target_http_date, - ) + serializer.write_timestamp(members[5], self.target_http_date) if self.target_date_time is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetDateTime" - ], - self.target_date_time, - ) + serializer.write_timestamp(members[6], self.target_date_time) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6125,65 +5538,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member_epoch_seconds"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberEpochSeconds" - ] - ) + kwargs["member_epoch_seconds"] = de.read_timestamp(members[0]) case 1: - kwargs["member_http_date"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberHttpDate" - ] - ) + kwargs["member_http_date"] = de.read_timestamp(members[1]) case 2: - kwargs["member_date_time"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberDateTime" - ] - ) + kwargs["member_date_time"] = de.read_timestamp(members[2]) case 3: - kwargs["default_format"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "defaultFormat" - ] - ) + kwargs["default_format"] = de.read_timestamp(members[3]) case 4: - kwargs["target_epoch_seconds"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetEpochSeconds" - ] - ) + kwargs["target_epoch_seconds"] = de.read_timestamp(members[4]) case 5: - kwargs["target_http_date"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetHttpDate" - ] - ) + kwargs["target_http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["target_date_time"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetDateTime" - ] - ) + kwargs["target_date_time"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6203,7 +5587,7 @@ class HttpRequestWithLabelsAndTimestampFormatOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -6216,28 +5600,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = APIOperation( input=HttpRequestWithLabelsAndTimestampFormatInput, output=HttpRequestWithLabelsAndTimestampFormatOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6248,13 +5627,16 @@ class HttpRequestWithRegexLiteralInput: str_: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT + ).members_by_index if self.str_ is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT.members["str"], self.str_ - ) + serializer.write_string(members[0], self.str_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6263,20 +5645,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["str_"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT.members["str"] - ) + kwargs["str_"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6295,7 +5675,9 @@ class HttpRequestWithRegexLiteralOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6307,27 +5689,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_REGEX_LITERAL = APIOperation( input=HttpRequestWithRegexLiteralInput, output=HttpRequestWithRegexLiteralOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_REGEX_LITERAL, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6336,7 +5714,7 @@ class HttpResponseCodeInput: """Dataclass for HttpResponseCodeInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_RESPONSE_CODE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_RESPONSE_CODE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6348,13 +5726,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_RESPONSE_CODE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_RESPONSE_CODE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6375,13 +5754,12 @@ class HttpResponseCodeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT).members_by_index if self.status is not None: - serializer.write_integer( - _SCHEMA_HTTP_RESPONSE_CODE_OUTPUT.members["Status"], self.status - ) + serializer.write_integer(members[0], self.status) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6390,30 +5768,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["status"] = de.read_integer( - _SCHEMA_HTTP_RESPONSE_CODE_OUTPUT.members["Status"] - ) + kwargs["status"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_RESPONSE_CODE = APIOperation( input=HttpResponseCodeInput, output=HttpResponseCodeOutput, - schema=_SCHEMA_HTTP_RESPONSE_CODE, - input_schema=_SCHEMA_HTTP_RESPONSE_CODE_INPUT, - output_schema=_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT, + static_schema=_SCHEMA_HTTP_RESPONSE_CODE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6424,13 +5799,12 @@ class HttpStringPayloadInput: payload: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_STRING_PAYLOAD_INPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6439,18 +5813,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_HTTP_STRING_PAYLOAD_INPUT.members["payload"] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6471,13 +5845,12 @@ class HttpStringPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6486,30 +5859,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT.members["payload"] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_STRING_PAYLOAD = APIOperation( input=HttpStringPayloadInput, output=HttpStringPayloadOutput, - schema=_SCHEMA_HTTP_STRING_PAYLOAD, - input_schema=_SCHEMA_HTTP_STRING_PAYLOAD_INPUT, - output_schema=_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_HTTP_STRING_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6518,7 +5888,9 @@ class IgnoreQueryParamsInResponseInput: """Dataclass for IgnoreQueryParamsInResponseInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6530,15 +5902,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6559,13 +5930,16 @@ class IgnoreQueryParamsInResponseOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT + ).members_by_index if self.baz is not None: - serializer.write_string( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT.members["baz"], self.baz - ) + serializer.write_string(members[0], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6574,32 +5948,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["baz"] = de.read_string( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT.members["baz"] - ) + kwargs["baz"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs IGNORE_QUERY_PARAMS_IN_RESPONSE = APIOperation( input=IgnoreQueryParamsInResponseInput, output=IgnoreQueryParamsInResponseOutput, - schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE, - input_schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, - output_schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, + static_schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6644,132 +6013,68 @@ class InputAndOutputWithHeadersInput: header_integer_enum_list: list[int] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT).members_by_index if self.header_string is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerString"], - self.header_string, - ) + serializer.write_string(members[0], self.header_string) if self.header_byte is not None: - serializer.write_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerByte"], - self.header_byte, - ) + serializer.write_byte(members[1], self.header_byte) if self.header_short is not None: - serializer.write_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerShort"], - self.header_short, - ) + serializer.write_short(members[2], self.header_short) if self.header_integer is not None: - serializer.write_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerInteger"], - self.header_integer, - ) + serializer.write_integer(members[3], self.header_integer) if self.header_long is not None: - serializer.write_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerLong"], - self.header_long, - ) + serializer.write_long(members[4], self.header_long) if self.header_float is not None: - serializer.write_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerFloat"], - self.header_float, - ) + serializer.write_float(members[5], self.header_float) if self.header_double is not None: - serializer.write_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerDouble"], - self.header_double, - ) + serializer.write_double(members[6], self.header_double) if self.header_true_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerTrueBool"], - self.header_true_bool, - ) + serializer.write_boolean(members[7], self.header_true_bool) if self.header_false_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerFalseBool"], - self.header_false_bool, - ) + serializer.write_boolean(members[8], self.header_false_bool) if self.header_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerStringList"], - self.header_string_list, - ) + _serialize_string_list(serializer, members[9], self.header_string_list) if self.header_string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerStringSet"], - self.header_string_set, - ) + _serialize_string_set(serializer, members[10], self.header_string_set) if self.header_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerList" - ], - self.header_integer_list, - ) + _serialize_integer_list(serializer, members[11], self.header_integer_list) if self.header_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerBooleanList" - ], - self.header_boolean_list, - ) + _serialize_boolean_list(serializer, members[12], self.header_boolean_list) if self.header_timestamp_list is not None: _serialize_timestamp_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerTimestampList" - ], - self.header_timestamp_list, + serializer, members[13], self.header_timestamp_list ) if self.header_enum is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerEnum"], - self.header_enum, - ) + serializer.write_string(members[14], self.header_enum) if self.header_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerEnumList"], - self.header_enum_list, - ) + _serialize_foo_enum_list(serializer, members[15], self.header_enum_list) if self.header_integer_enum is not None: - serializer.write_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerEnum" - ], - self.header_integer_enum, - ) + serializer.write_integer(members[16], self.header_integer_enum) if self.header_integer_enum_list is not None: _serialize_integer_enum_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerEnumList" - ], - self.header_integer_enum_list, + serializer, members[17], self.header_integer_enum_list ) @classmethod @@ -6779,152 +6084,85 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header_string"] = de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerString" - ] - ) + kwargs["header_string"] = de.read_string(members[0]) case 1: - kwargs["header_byte"] = de.read_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerByte" - ] - ) + kwargs["header_byte"] = de.read_byte(members[1]) case 2: - kwargs["header_short"] = de.read_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerShort" - ] - ) + kwargs["header_short"] = de.read_short(members[2]) case 3: - kwargs["header_integer"] = de.read_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerInteger" - ] - ) + kwargs["header_integer"] = de.read_integer(members[3]) case 4: - kwargs["header_long"] = de.read_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerLong" - ] - ) + kwargs["header_long"] = de.read_long(members[4]) case 5: - kwargs["header_float"] = de.read_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerFloat" - ] - ) + kwargs["header_float"] = de.read_float(members[5]) case 6: - kwargs["header_double"] = de.read_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerDouble" - ] - ) + kwargs["header_double"] = de.read_double(members[6]) case 7: - kwargs["header_true_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerTrueBool" - ] - ) + kwargs["header_true_bool"] = de.read_boolean(members[7]) case 8: - kwargs["header_false_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerFalseBool" - ] - ) + kwargs["header_false_bool"] = de.read_boolean(members[8]) case 9: kwargs["header_string_list"] = _deserialize_string_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerStringList" - ], + de, members[9] ) case 10: kwargs["header_string_set"] = _deserialize_string_set( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerStringSet" - ], + de, members[10] ) case 11: kwargs["header_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerList" - ], + de, members[11] ) case 12: kwargs["header_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerBooleanList" - ], + de, members[12] ) case 13: kwargs["header_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerTimestampList" - ], + de, members[13] ) case 14: - kwargs["header_enum"] = FooEnum( - de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerEnum" - ] - ) - ) + kwargs["header_enum"] = FooEnum(de.read_string(members[14])) case 15: kwargs["header_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerEnumList" - ], + de, members[15] ) case 16: kwargs["header_integer_enum"] = IntegerEnum( - de.read_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerEnum" - ] - ) + de.read_integer(members[16]) ) case 17: kwargs["header_integer_enum_list"] = _deserialize_integer_enum_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerEnumList" - ], + de, members[17] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6979,134 +6217,68 @@ class InputAndOutputWithHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT).members_by_index if self.header_string is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerString"], - self.header_string, - ) + serializer.write_string(members[0], self.header_string) if self.header_byte is not None: - serializer.write_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerByte"], - self.header_byte, - ) + serializer.write_byte(members[1], self.header_byte) if self.header_short is not None: - serializer.write_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerShort"], - self.header_short, - ) + serializer.write_short(members[2], self.header_short) if self.header_integer is not None: - serializer.write_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerInteger"], - self.header_integer, - ) + serializer.write_integer(members[3], self.header_integer) if self.header_long is not None: - serializer.write_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerLong"], - self.header_long, - ) + serializer.write_long(members[4], self.header_long) if self.header_float is not None: - serializer.write_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerFloat"], - self.header_float, - ) + serializer.write_float(members[5], self.header_float) if self.header_double is not None: - serializer.write_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerDouble"], - self.header_double, - ) + serializer.write_double(members[6], self.header_double) if self.header_true_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerTrueBool"], - self.header_true_bool, - ) + serializer.write_boolean(members[7], self.header_true_bool) if self.header_false_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerFalseBool"], - self.header_false_bool, - ) + serializer.write_boolean(members[8], self.header_false_bool) if self.header_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerStringList" - ], - self.header_string_list, - ) + _serialize_string_list(serializer, members[9], self.header_string_list) if self.header_string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerStringSet"], - self.header_string_set, - ) + _serialize_string_set(serializer, members[10], self.header_string_set) if self.header_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerList" - ], - self.header_integer_list, - ) + _serialize_integer_list(serializer, members[11], self.header_integer_list) if self.header_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerBooleanList" - ], - self.header_boolean_list, - ) + _serialize_boolean_list(serializer, members[12], self.header_boolean_list) if self.header_timestamp_list is not None: _serialize_timestamp_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerTimestampList" - ], - self.header_timestamp_list, + serializer, members[13], self.header_timestamp_list ) if self.header_enum is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerEnum"], - self.header_enum, - ) + serializer.write_string(members[14], self.header_enum) if self.header_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerEnumList"], - self.header_enum_list, - ) + _serialize_foo_enum_list(serializer, members[15], self.header_enum_list) if self.header_integer_enum is not None: - serializer.write_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerEnum" - ], - self.header_integer_enum, - ) + serializer.write_integer(members[16], self.header_integer_enum) if self.header_integer_enum_list is not None: _serialize_integer_enum_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerEnumList" - ], - self.header_integer_enum_list, + serializer, members[17], self.header_integer_enum_list ) @classmethod @@ -7116,164 +6288,94 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header_string"] = de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerString" - ] - ) + kwargs["header_string"] = de.read_string(members[0]) case 1: - kwargs["header_byte"] = de.read_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerByte" - ] - ) + kwargs["header_byte"] = de.read_byte(members[1]) case 2: - kwargs["header_short"] = de.read_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerShort" - ] - ) + kwargs["header_short"] = de.read_short(members[2]) case 3: - kwargs["header_integer"] = de.read_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerInteger" - ] - ) + kwargs["header_integer"] = de.read_integer(members[3]) case 4: - kwargs["header_long"] = de.read_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerLong" - ] - ) + kwargs["header_long"] = de.read_long(members[4]) case 5: - kwargs["header_float"] = de.read_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerFloat" - ] - ) + kwargs["header_float"] = de.read_float(members[5]) case 6: - kwargs["header_double"] = de.read_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerDouble" - ] - ) + kwargs["header_double"] = de.read_double(members[6]) case 7: - kwargs["header_true_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerTrueBool" - ] - ) + kwargs["header_true_bool"] = de.read_boolean(members[7]) case 8: - kwargs["header_false_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerFalseBool" - ] - ) + kwargs["header_false_bool"] = de.read_boolean(members[8]) case 9: kwargs["header_string_list"] = _deserialize_string_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerStringList" - ], + de, members[9] ) case 10: kwargs["header_string_set"] = _deserialize_string_set( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerStringSet" - ], + de, members[10] ) case 11: kwargs["header_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerList" - ], + de, members[11] ) case 12: kwargs["header_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerBooleanList" - ], + de, members[12] ) case 13: kwargs["header_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerTimestampList" - ], + de, members[13] ) case 14: - kwargs["header_enum"] = FooEnum( - de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerEnum" - ] - ) - ) + kwargs["header_enum"] = FooEnum(de.read_string(members[14])) case 15: kwargs["header_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerEnumList" - ], + de, members[15] ) case 16: kwargs["header_integer_enum"] = IntegerEnum( - de.read_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerEnum" - ] - ) + de.read_integer(members[16]) ) case 17: kwargs["header_integer_enum_list"] = _deserialize_integer_enum_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerEnumList" - ], + de, members[17] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs INPUT_AND_OUTPUT_WITH_HEADERS = APIOperation( input=InputAndOutputWithHeadersInput, output=InputAndOutputWithHeadersOutput, - schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS, - input_schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, - output_schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, + static_schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7282,7 +6384,7 @@ class InputStreamInput: """Dataclass for InputStreamInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_STREAM_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_INPUT_STREAM_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -7294,13 +6396,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_STREAM_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INPUT_STREAM_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7319,7 +6422,7 @@ class InputStreamOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_INPUT_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -7331,25 +6434,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_STREAM_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INPUT_STREAM_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs INPUT_STREAM = APIOperation( input=InputStreamInput, output=InputStreamOutput, - schema=_SCHEMA_INPUT_STREAM, - input_schema=_SCHEMA_INPUT_STREAM_INPUT, - output_schema=_SCHEMA_INPUT_STREAM_OUTPUT, + static_schema=_SCHEMA_INPUT_STREAM, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7360,16 +6461,16 @@ class InputStreamWithInitialRequestInput: initial_request_member: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT + ).members_by_index if self.initial_request_member is not None: - serializer.write_string( - _SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT.members[ - "initialRequestMember" - ], - self.initial_request_member, - ) + serializer.write_string(members[0], self.initial_request_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7378,22 +6479,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["initial_request_member"] = de.read_string( - _SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT.members[ - "initialRequestMember" - ] - ) + kwargs["initial_request_member"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7412,7 +6509,9 @@ class InputStreamWithInitialRequestOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -7424,27 +6523,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs INPUT_STREAM_WITH_INITIAL_REQUEST = APIOperation( input=InputStreamWithInitialRequestInput, output=InputStreamWithInitialRequestOutput, - schema=_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST, - input_schema=_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT, - output_schema=_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT, + static_schema=_SCHEMA_INPUT_STREAM_WITH_INITIAL_REQUEST, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7455,11 +6550,12 @@ class JsonBlobsInput: data: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_BLOBS_INPUT).members_by_index if self.data is not None: - serializer.write_blob(_SCHEMA_JSON_BLOBS_INPUT.members["data"], self.data) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7468,18 +6564,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_BLOBS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_JSON_BLOBS_INPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7500,11 +6596,12 @@ class JsonBlobsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_BLOBS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_BLOBS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_BLOBS_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob(_SCHEMA_JSON_BLOBS_OUTPUT.members["data"], self.data) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7513,30 +6610,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_BLOBS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_JSON_BLOBS_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_BLOBS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_BLOBS = APIOperation( input=JsonBlobsInput, output=JsonBlobsOutput, - schema=_SCHEMA_JSON_BLOBS, - input_schema=_SCHEMA_JSON_BLOBS_INPUT, - output_schema=_SCHEMA_JSON_BLOBS_OUTPUT, + static_schema=_SCHEMA_JSON_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7544,7 +6638,7 @@ def _serialize_foo_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -7553,7 +6647,7 @@ def _deserialize_foo_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -7569,7 +6663,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_foo_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -7579,7 +6673,7 @@ def _deserialize_foo_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -7609,44 +6703,27 @@ class JsonEnumsInput: foo_enum_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_ENUMS_INPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7655,43 +6732,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_ENUMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_INPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_INPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_INPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_JSON_ENUMS_INPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7722,44 +6789,27 @@ class JsonEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_ENUMS_OUTPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7768,55 +6818,42 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_JSON_ENUMS_OUTPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_ENUMS = APIOperation( input=JsonEnumsInput, output=JsonEnumsOutput, - schema=_SCHEMA_JSON_ENUMS, - input_schema=_SCHEMA_JSON_ENUMS_INPUT, - output_schema=_SCHEMA_JSON_ENUMS_OUTPUT, + static_schema=_SCHEMA_JSON_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7824,7 +6861,7 @@ def _serialize_integer_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -7833,7 +6870,7 @@ def _deserialize_integer_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -7849,7 +6886,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_integer_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -7859,7 +6896,7 @@ def _deserialize_integer_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -7889,44 +6926,27 @@ class JsonIntEnumsInput: integer_enum_map: dict[str, int] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_INT_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_INT_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_INT_ENUMS_INPUT).members_by_index if self.integer_enum1 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnum1"], self.integer_enum1 - ) + serializer.write_integer(members[0], self.integer_enum1) if self.integer_enum2 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnum2"], self.integer_enum2 - ) + serializer.write_integer(members[1], self.integer_enum2) if self.integer_enum3 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnum3"], self.integer_enum3 - ) + serializer.write_integer(members[2], self.integer_enum3) if self.integer_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnumList"], - self.integer_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.integer_enum_list) if self.integer_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnumSet"], - self.integer_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.integer_enum_set) if self.integer_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnumMap"], - self.integer_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.integer_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7935,49 +6955,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_INT_ENUMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["integer_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnum1"] - ) - ) + kwargs["integer_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["integer_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnum2"] - ) - ) + kwargs["integer_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["integer_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnum3"] - ) - ) + kwargs["integer_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["integer_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnumList"] + de, members[3] ) case 4: kwargs["integer_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnumSet"] + de, members[4] ) case 5: kwargs["integer_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_JSON_INT_ENUMS_INPUT.members["integerEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_INT_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8008,47 +7018,27 @@ class JsonIntEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_INT_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_INT_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_INT_ENUMS_OUTPUT).members_by_index if self.integer_enum1 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnum1"], - self.integer_enum1, - ) + serializer.write_integer(members[0], self.integer_enum1) if self.integer_enum2 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnum2"], - self.integer_enum2, - ) + serializer.write_integer(members[1], self.integer_enum2) if self.integer_enum3 is not None: - serializer.write_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnum3"], - self.integer_enum3, - ) + serializer.write_integer(members[2], self.integer_enum3) if self.integer_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnumList"], - self.integer_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.integer_enum_list) if self.integer_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnumSet"], - self.integer_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.integer_enum_set) if self.integer_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnumMap"], - self.integer_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.integer_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8057,68 +7047,55 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_INT_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["integer_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnum1"] - ) - ) + kwargs["integer_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["integer_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnum2"] - ) - ) + kwargs["integer_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["integer_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnum3"] - ) - ) + kwargs["integer_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["integer_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnumList"] + de, members[3] ) case 4: kwargs["integer_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnumSet"] + de, members[4] ) case 5: kwargs["integer_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_JSON_INT_ENUMS_OUTPUT.members["integerEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_INT_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_INT_ENUMS = APIOperation( input=JsonIntEnumsInput, output=JsonIntEnumsOutput, - schema=_SCHEMA_JSON_INT_ENUMS, - input_schema=_SCHEMA_JSON_INT_ENUMS_INPUT, - output_schema=_SCHEMA_JSON_INT_ENUMS_OUTPUT, + static_schema=_SCHEMA_JSON_INT_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_nested_string_list( serializer: ShapeSerializer, schema: Schema, value: list[list[str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_string_list(ls, member_schema, e) @@ -8128,7 +7105,7 @@ def _deserialize_nested_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[list[str]]: result: list[list[str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -8150,14 +7127,15 @@ class StructureListMember: b: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER).members_by_index if self.a is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["a"], self.a) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["b"], self.b) + serializer.write_string(members[1], self.b) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8166,30 +7144,28 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_structure_list( serializer: ShapeSerializer, schema: Schema, value: list[StructureListMember] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8235,69 +7211,38 @@ class JsonListsInput: structure_list: list[StructureListMember] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_LISTS_INPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, _SCHEMA_JSON_LISTS_INPUT.members["enumList"], self.enum_list - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_JSON_LISTS_INPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[8], self.structure_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8306,58 +7251,50 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_JSON_LISTS_INPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_JSON_LISTS_INPUT.members["structureList"] + de, members[8] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8395,71 +7332,38 @@ class JsonListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_LISTS_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_JSON_LISTS_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[8], self.structure_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8468,70 +7372,59 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_JSON_LISTS_OUTPUT.members["structureList"] + de, members[8] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_LISTS = APIOperation( input=JsonListsInput, output=JsonListsOutput, - schema=_SCHEMA_JSON_LISTS, - input_schema=_SCHEMA_JSON_LISTS_INPUT, - output_schema=_SCHEMA_JSON_LISTS_OUTPUT, + static_schema=_SCHEMA_JSON_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -8550,43 +7443,24 @@ class JsonMapsInput: dense_set_map: dict[str, list[str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_MAPS_INPUT).members_by_index if self.dense_struct_map is not None: - _serialize_dense_struct_map( - serializer, - _SCHEMA_JSON_MAPS_INPUT.members["denseStructMap"], - self.dense_struct_map, - ) + _serialize_dense_struct_map(serializer, members[0], self.dense_struct_map) if self.dense_number_map is not None: - _serialize_dense_number_map( - serializer, - _SCHEMA_JSON_MAPS_INPUT.members["denseNumberMap"], - self.dense_number_map, - ) + _serialize_dense_number_map(serializer, members[1], self.dense_number_map) if self.dense_boolean_map is not None: - _serialize_dense_boolean_map( - serializer, - _SCHEMA_JSON_MAPS_INPUT.members["denseBooleanMap"], - self.dense_boolean_map, - ) + _serialize_dense_boolean_map(serializer, members[2], self.dense_boolean_map) if self.dense_string_map is not None: - _serialize_dense_string_map( - serializer, - _SCHEMA_JSON_MAPS_INPUT.members["denseStringMap"], - self.dense_string_map, - ) + _serialize_dense_string_map(serializer, members[3], self.dense_string_map) if self.dense_set_map is not None: - _serialize_dense_set_map( - serializer, - _SCHEMA_JSON_MAPS_INPUT.members["denseSetMap"], - self.dense_set_map, - ) + _serialize_dense_set_map(serializer, members[4], self.dense_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8595,38 +7469,38 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dense_struct_map"] = _deserialize_dense_struct_map( - de, _SCHEMA_JSON_MAPS_INPUT.members["denseStructMap"] + de, members[0] ) case 1: kwargs["dense_number_map"] = _deserialize_dense_number_map( - de, _SCHEMA_JSON_MAPS_INPUT.members["denseNumberMap"] + de, members[1] ) case 2: kwargs["dense_boolean_map"] = _deserialize_dense_boolean_map( - de, _SCHEMA_JSON_MAPS_INPUT.members["denseBooleanMap"] + de, members[2] ) case 3: kwargs["dense_string_map"] = _deserialize_dense_string_map( - de, _SCHEMA_JSON_MAPS_INPUT.members["denseStringMap"] + de, members[3] ) case 4: - kwargs["dense_set_map"] = _deserialize_dense_set_map( - de, _SCHEMA_JSON_MAPS_INPUT.members["denseSetMap"] - ) + kwargs["dense_set_map"] = _deserialize_dense_set_map(de, members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8655,43 +7529,24 @@ class JsonMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_MAPS_OUTPUT).members_by_index if self.dense_struct_map is not None: - _serialize_dense_struct_map( - serializer, - _SCHEMA_JSON_MAPS_OUTPUT.members["denseStructMap"], - self.dense_struct_map, - ) + _serialize_dense_struct_map(serializer, members[0], self.dense_struct_map) if self.dense_number_map is not None: - _serialize_dense_number_map( - serializer, - _SCHEMA_JSON_MAPS_OUTPUT.members["denseNumberMap"], - self.dense_number_map, - ) + _serialize_dense_number_map(serializer, members[1], self.dense_number_map) if self.dense_boolean_map is not None: - _serialize_dense_boolean_map( - serializer, - _SCHEMA_JSON_MAPS_OUTPUT.members["denseBooleanMap"], - self.dense_boolean_map, - ) + _serialize_dense_boolean_map(serializer, members[2], self.dense_boolean_map) if self.dense_string_map is not None: - _serialize_dense_string_map( - serializer, - _SCHEMA_JSON_MAPS_OUTPUT.members["denseStringMap"], - self.dense_string_map, - ) + _serialize_dense_string_map(serializer, members[3], self.dense_string_map) if self.dense_set_map is not None: - _serialize_dense_set_map( - serializer, - _SCHEMA_JSON_MAPS_OUTPUT.members["denseSetMap"], - self.dense_set_map, - ) + _serialize_dense_set_map(serializer, members[4], self.dense_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8700,50 +7555,47 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dense_struct_map"] = _deserialize_dense_struct_map( - de, _SCHEMA_JSON_MAPS_OUTPUT.members["denseStructMap"] + de, members[0] ) case 1: kwargs["dense_number_map"] = _deserialize_dense_number_map( - de, _SCHEMA_JSON_MAPS_OUTPUT.members["denseNumberMap"] + de, members[1] ) case 2: kwargs["dense_boolean_map"] = _deserialize_dense_boolean_map( - de, _SCHEMA_JSON_MAPS_OUTPUT.members["denseBooleanMap"] + de, members[2] ) case 3: kwargs["dense_string_map"] = _deserialize_dense_string_map( - de, _SCHEMA_JSON_MAPS_OUTPUT.members["denseStringMap"] + de, members[3] ) case 4: - kwargs["dense_set_map"] = _deserialize_dense_set_map( - de, _SCHEMA_JSON_MAPS_OUTPUT.members["denseSetMap"] - ) + kwargs["dense_set_map"] = _deserialize_dense_set_map(de, members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_MAPS = APIOperation( input=JsonMapsInput, output=JsonMapsOutput, - schema=_SCHEMA_JSON_MAPS, - input_schema=_SCHEMA_JSON_MAPS_INPUT, - output_schema=_SCHEMA_JSON_MAPS_OUTPUT, + static_schema=_SCHEMA_JSON_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -8766,47 +7618,30 @@ class JsonTimestampsInput: http_date_on_target: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_TIMESTAMPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_TIMESTAMPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_TIMESTAMPS_INPUT).members_by_index if self.normal is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["normal"], self.normal - ) + serializer.write_timestamp(members[0], self.normal) if self.date_time is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["dateTime"], self.date_time - ) + serializer.write_timestamp(members[1], self.date_time) if self.date_time_on_target is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["dateTimeOnTarget"], - self.date_time_on_target, - ) + serializer.write_timestamp(members[2], self.date_time_on_target) if self.epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["epochSeconds"], - self.epoch_seconds, - ) + serializer.write_timestamp(members[3], self.epoch_seconds) if self.epoch_seconds_on_target is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["epochSecondsOnTarget"], - self.epoch_seconds_on_target, - ) + serializer.write_timestamp(members[4], self.epoch_seconds_on_target) if self.http_date is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["httpDate"], self.http_date - ) + serializer.write_timestamp(members[5], self.http_date) if self.http_date_on_target is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["httpDateOnTarget"], - self.http_date_on_target, - ) + serializer.write_timestamp(members[6], self.http_date_on_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8815,48 +7650,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_TIMESTAMPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["normal"] - ) + kwargs["normal"] = de.read_timestamp(members[0]) case 1: - kwargs["date_time"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["dateTime"] - ) + kwargs["date_time"] = de.read_timestamp(members[1]) case 2: - kwargs["date_time_on_target"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["dateTimeOnTarget"] - ) + kwargs["date_time_on_target"] = de.read_timestamp(members[2]) case 3: - kwargs["epoch_seconds"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["epochSeconds"] - ) + kwargs["epoch_seconds"] = de.read_timestamp(members[3]) case 4: - kwargs["epoch_seconds_on_target"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["epochSecondsOnTarget"] - ) + kwargs["epoch_seconds_on_target"] = de.read_timestamp(members[4]) case 5: - kwargs["http_date"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["httpDate"] - ) + kwargs["http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["http_date_on_target"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_INPUT.members["httpDateOnTarget"] - ) + kwargs["http_date_on_target"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_TIMESTAMPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8889,47 +7712,30 @@ class JsonTimestampsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_TIMESTAMPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_TIMESTAMPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_TIMESTAMPS_OUTPUT).members_by_index if self.normal is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["normal"], self.normal - ) + serializer.write_timestamp(members[0], self.normal) if self.date_time is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["dateTime"], self.date_time - ) + serializer.write_timestamp(members[1], self.date_time) if self.date_time_on_target is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"], - self.date_time_on_target, - ) + serializer.write_timestamp(members[2], self.date_time_on_target) if self.epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["epochSeconds"], - self.epoch_seconds, - ) + serializer.write_timestamp(members[3], self.epoch_seconds) if self.epoch_seconds_on_target is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"], - self.epoch_seconds_on_target, - ) + serializer.write_timestamp(members[4], self.epoch_seconds_on_target) if self.http_date is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["httpDate"], self.http_date - ) + serializer.write_timestamp(members[5], self.http_date) if self.http_date_on_target is not None: - serializer.write_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"], - self.http_date_on_target, - ) + serializer.write_timestamp(members[6], self.http_date_on_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8938,60 +7744,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_TIMESTAMPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["normal"] - ) + kwargs["normal"] = de.read_timestamp(members[0]) case 1: - kwargs["date_time"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["dateTime"] - ) + kwargs["date_time"] = de.read_timestamp(members[1]) case 2: - kwargs["date_time_on_target"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"] - ) + kwargs["date_time_on_target"] = de.read_timestamp(members[2]) case 3: - kwargs["epoch_seconds"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["epochSeconds"] - ) + kwargs["epoch_seconds"] = de.read_timestamp(members[3]) case 4: - kwargs["epoch_seconds_on_target"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"] - ) + kwargs["epoch_seconds_on_target"] = de.read_timestamp(members[4]) case 5: - kwargs["http_date"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["httpDate"] - ) + kwargs["http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["http_date_on_target"] = de.read_timestamp( - _SCHEMA_JSON_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"] - ) + kwargs["http_date_on_target"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_TIMESTAMPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_TIMESTAMPS = APIOperation( input=JsonTimestampsInput, output=JsonTimestampsOutput, - schema=_SCHEMA_JSON_TIMESTAMPS, - input_schema=_SCHEMA_JSON_TIMESTAMPS_INPUT, - output_schema=_SCHEMA_JSON_TIMESTAMPS_OUTPUT, + static_schema=_SCHEMA_JSON_TIMESTAMPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9002,13 +7793,12 @@ class RenamedGreeting: salutation: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RENAMED_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_RENAMED_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RENAMED_GREETING).members_by_index if self.salutation is not None: - serializer.write_string( - _SCHEMA_RENAMED_GREETING.members["salutation"], self.salutation - ) + serializer.write_string(members[0], self.salutation) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9017,18 +7807,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RENAMED_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["salutation"] = de.read_string( - _SCHEMA_RENAMED_GREETING.members["salutation"] - ) + kwargs["salutation"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RENAMED_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9037,16 +7827,16 @@ class NestedUnionStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_NESTED_UNION.members["stringValue"], self.value) + members = hydrate(_SCHEMA_NESTED_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_NESTED_UNION.members["stringValue"]) - ) + members = hydrate(_SCHEMA_NESTED_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -9082,7 +7872,7 @@ class _NestedUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> NestedUnion: self._result = None - deserializer.read_struct(_SCHEMA_NESTED_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_NESTED_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -9112,16 +7902,16 @@ class MyUnionStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MY_UNION.members["stringValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_MY_UNION.members["stringValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -9129,16 +7919,16 @@ class MyUnionBooleanValue: value: bool def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_boolean(_SCHEMA_MY_UNION.members["booleanValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_boolean(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_boolean(_SCHEMA_MY_UNION.members["booleanValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_boolean(members[1])) @dataclass @@ -9146,16 +7936,16 @@ class MyUnionNumberValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer(_SCHEMA_MY_UNION.members["numberValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_integer(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_integer(_SCHEMA_MY_UNION.members["numberValue"]) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_integer(members[2])) @dataclass @@ -9163,14 +7953,16 @@ class MyUnionBlobValue: value: bytes def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_blob(_SCHEMA_MY_UNION.members["blobValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_blob(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_blob(_SCHEMA_MY_UNION.members["blobValue"])) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_blob(members[3])) @dataclass @@ -9178,20 +7970,16 @@ class MyUnionTimestampValue: value: datetime def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_timestamp( - _SCHEMA_MY_UNION.members["timestampValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_timestamp(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_timestamp( - _SCHEMA_MY_UNION.members["timestampValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=deserializer.read_timestamp(members[4])) @dataclass @@ -9199,18 +7987,16 @@ class MyUnionEnumValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_MY_UNION.members["enumValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_string(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=FooEnum( - deserializer.read_string(_SCHEMA_MY_UNION.members["enumValue"]) - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=FooEnum(deserializer.read_string(members[5]))) @dataclass @@ -9218,20 +8004,16 @@ class MyUnionListValue: value: list[str] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_string_list( - serializer, _SCHEMA_MY_UNION.members["listValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + _serialize_string_list(serializer, members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_string_list( - deserializer, _SCHEMA_MY_UNION.members["listValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=_deserialize_string_list(deserializer, members[6])) @dataclass @@ -9239,20 +8021,16 @@ class MyUnionMapValue: value: dict[str, str] def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - _serialize_string_map( - serializer, _SCHEMA_MY_UNION.members["mapValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + _serialize_string_map(serializer, members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=_deserialize_string_map( - deserializer, _SCHEMA_MY_UNION.members["mapValue"] - ) - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + return cls(value=_deserialize_string_map(deserializer, members[7])) @dataclass @@ -9260,10 +8038,11 @@ class MyUnionStructureValue: value: GreetingStruct def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION.members["structureValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_struct(members[8], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9275,12 +8054,11 @@ class MyUnionRenamedStructureValue: value: RenamedGreeting def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_MY_UNION.members["renamedStructureValue"], self.value - ) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_struct(members[9], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9294,10 +8072,11 @@ class MyUnionUnionValue: value: NestedUnion def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_MY_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MY_UNION.members["unionValue"], self.value) + members = hydrate(_SCHEMA_MY_UNION).members_by_index + serializer.write_struct(members[10], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9350,7 +8129,7 @@ class _MyUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> MyUnion: self._result = None - deserializer.read_struct(_SCHEMA_MY_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_MY_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -9413,13 +8192,12 @@ class JsonUnionsInput: """A union with a representative set of types for members.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_UNIONS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_UNIONS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_UNIONS_INPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_JSON_UNIONS_INPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9428,16 +8206,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_UNIONS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _MyUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_UNIONS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9459,13 +8239,12 @@ class JsonUnionsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_JSON_UNIONS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_JSON_UNIONS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_JSON_UNIONS_OUTPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_JSON_UNIONS_OUTPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9474,28 +8253,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_JSON_UNIONS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _MyUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_JSON_UNIONS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs JSON_UNIONS = APIOperation( input=JsonUnionsInput, output=JsonUnionsOutput, - schema=_SCHEMA_JSON_UNIONS, - input_schema=_SCHEMA_JSON_UNIONS_INPUT, - output_schema=_SCHEMA_JSON_UNIONS_OUTPUT, + static_schema=_SCHEMA_JSON_UNIONS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9504,7 +8282,7 @@ class MalformedAcceptWithBodyInput: """Dataclass for MalformedAcceptWithBodyInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -9516,15 +8294,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_BODY_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9545,13 +8322,14 @@ class MalformedAcceptWithBodyOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT).members_by_index if self.hi is not None: - serializer.write_string( - _SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT.members["hi"], self.hi - ) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9560,32 +8338,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string( - _SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT.members["hi"] - ) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_ACCEPT_WITH_BODY = APIOperation( input=MalformedAcceptWithBodyInput, output=MalformedAcceptWithBodyOutput, - schema=_SCHEMA_MALFORMED_ACCEPT_WITH_BODY, - input_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_INPUT, - output_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_BODY_OUTPUT, + static_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_BODY, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9595,7 +8368,7 @@ class MalformedAcceptWithGenericStringInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT, self + hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -9608,15 +8381,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9638,15 +8410,15 @@ class MalformedAcceptWithGenericStringOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT + ).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT.members["payload"], - self.payload, - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9655,34 +8427,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT.members[ - "payload" - ] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_ACCEPT_WITH_GENERIC_STRING = APIOperation( input=MalformedAcceptWithGenericStringInput, output=MalformedAcceptWithGenericStringOutput, - schema=_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING, - input_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT, - output_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT, + static_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_GENERIC_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9691,7 +8456,9 @@ class MalformedAcceptWithPayloadInput: """Dataclass for MalformedAcceptWithPayloadInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -9703,15 +8470,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9732,14 +8498,14 @@ class MalformedAcceptWithPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT).members_by_index if self.payload is not None: - serializer.write_blob( - _SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT.members["payload"], - self.payload, - ) + serializer.write_blob(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9748,32 +8514,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_blob( - _SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT.members["payload"] - ) + kwargs["payload"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_ACCEPT_WITH_PAYLOAD = APIOperation( input=MalformedAcceptWithPayloadInput, output=MalformedAcceptWithPayloadOutput, - schema=_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD, - input_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT, - output_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_MALFORMED_ACCEPT_WITH_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9784,13 +8545,12 @@ class MalformedBlobInput: blob: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_BLOB_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_BLOB_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_BLOB_INPUT).members_by_index if self.blob is not None: - serializer.write_blob( - _SCHEMA_MALFORMED_BLOB_INPUT.members["blob"], self.blob - ) + serializer.write_blob(members[0], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9799,18 +8559,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_BLOB_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["blob"] = de.read_blob( - _SCHEMA_MALFORMED_BLOB_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_BLOB_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9829,7 +8589,7 @@ class MalformedBlobOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_BLOB_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_BLOB_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -9841,25 +8601,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_BLOB_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_BLOB_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_BLOB = APIOperation( input=MalformedBlobInput, output=MalformedBlobOutput, - schema=_SCHEMA_MALFORMED_BLOB, - input_schema=_SCHEMA_MALFORMED_BLOB_INPUT, - output_schema=_SCHEMA_MALFORMED_BLOB_OUTPUT, + static_schema=_SCHEMA_MALFORMED_BLOB, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9876,32 +8634,21 @@ class MalformedBooleanInput: boolean_in_header: bool | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_BOOLEAN_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_BOOLEAN_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_BOOLEAN_INPUT).members_by_index if self.boolean_in_body is not None: - serializer.write_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInBody"], - self.boolean_in_body, - ) + serializer.write_boolean(members[0], self.boolean_in_body) if self.boolean_in_path is not None: - serializer.write_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInPath"], - self.boolean_in_path, - ) + serializer.write_boolean(members[1], self.boolean_in_path) if self.boolean_in_query is not None: - serializer.write_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInQuery"], - self.boolean_in_query, - ) + serializer.write_boolean(members[2], self.boolean_in_query) if self.boolean_in_header is not None: - serializer.write_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInHeader"], - self.boolean_in_header, - ) + serializer.write_boolean(members[3], self.boolean_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9910,33 +8657,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_BOOLEAN_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["boolean_in_body"] = de.read_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInBody"] - ) + kwargs["boolean_in_body"] = de.read_boolean(members[0]) case 1: - kwargs["boolean_in_path"] = de.read_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInPath"] - ) + kwargs["boolean_in_path"] = de.read_boolean(members[1]) case 2: - kwargs["boolean_in_query"] = de.read_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInQuery"] - ) + kwargs["boolean_in_query"] = de.read_boolean(members[2]) case 3: - kwargs["boolean_in_header"] = de.read_boolean( - _SCHEMA_MALFORMED_BOOLEAN_INPUT.members["booleanInHeader"] - ) + kwargs["boolean_in_header"] = de.read_boolean(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_BOOLEAN_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9955,7 +8696,7 @@ class MalformedBooleanOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_BOOLEAN_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_BOOLEAN_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -9967,25 +8708,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_BOOLEAN_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_BOOLEAN_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_BOOLEAN = APIOperation( input=MalformedBooleanInput, output=MalformedBooleanOutput, - schema=_SCHEMA_MALFORMED_BOOLEAN, - input_schema=_SCHEMA_MALFORMED_BOOLEAN_INPUT, - output_schema=_SCHEMA_MALFORMED_BOOLEAN_OUTPUT, + static_schema=_SCHEMA_MALFORMED_BOOLEAN, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10002,29 +8741,21 @@ class MalformedByteInput: byte_in_header: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_BYTE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_BYTE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_BYTE_INPUT).members_by_index if self.byte_in_body is not None: - serializer.write_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInBody"], self.byte_in_body - ) + serializer.write_byte(members[0], self.byte_in_body) if self.byte_in_path is not None: - serializer.write_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInPath"], self.byte_in_path - ) + serializer.write_byte(members[1], self.byte_in_path) if self.byte_in_query is not None: - serializer.write_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInQuery"], self.byte_in_query - ) + serializer.write_byte(members[2], self.byte_in_query) if self.byte_in_header is not None: - serializer.write_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInHeader"], - self.byte_in_header, - ) + serializer.write_byte(members[3], self.byte_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10033,33 +8764,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_BYTE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["byte_in_body"] = de.read_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInBody"] - ) + kwargs["byte_in_body"] = de.read_byte(members[0]) case 1: - kwargs["byte_in_path"] = de.read_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInPath"] - ) + kwargs["byte_in_path"] = de.read_byte(members[1]) case 2: - kwargs["byte_in_query"] = de.read_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInQuery"] - ) + kwargs["byte_in_query"] = de.read_byte(members[2]) case 3: - kwargs["byte_in_header"] = de.read_byte( - _SCHEMA_MALFORMED_BYTE_INPUT.members["byteInHeader"] - ) + kwargs["byte_in_header"] = de.read_byte(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_BYTE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10078,7 +8803,7 @@ class MalformedByteOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_BYTE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_BYTE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -10090,25 +8815,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_BYTE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_BYTE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_BYTE = APIOperation( input=MalformedByteInput, output=MalformedByteOutput, - schema=_SCHEMA_MALFORMED_BYTE, - input_schema=_SCHEMA_MALFORMED_BYTE_INPUT, - output_schema=_SCHEMA_MALFORMED_BYTE_OUTPUT, + static_schema=_SCHEMA_MALFORMED_BYTE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10119,13 +8842,16 @@ class MalformedContentTypeWithBodyInput: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT + ).members_by_index if self.hi is not None: - serializer.write_string( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT.members["hi"], self.hi - ) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10134,20 +8860,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT.members["hi"] - ) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10166,7 +8890,9 @@ class MalformedContentTypeWithBodyOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -10178,27 +8904,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_CONTENT_TYPE_WITH_BODY = APIOperation( input=MalformedContentTypeWithBodyInput, output=MalformedContentTypeWithBodyOutput, - schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY, - input_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT, - output_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT, + static_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_BODY, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10210,17 +8932,15 @@ class MalformedContentTypeWithGenericStringInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT, self + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT + ).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT.members[ - "payload" - ], - self.payload, - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10229,22 +8949,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT.members[ - "payload" - ] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10264,7 +8980,7 @@ class MalformedContentTypeWithGenericStringOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -10277,28 +8993,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING = APIOperation( input=MalformedContentTypeWithGenericStringInput, output=MalformedContentTypeWithGenericStringOutput, - schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING, - input_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT, - output_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT, + static_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10307,7 +9018,9 @@ class MalformedContentTypeWithoutBodyInput: """Dataclass for MalformedContentTypeWithoutBodyInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -10319,15 +9032,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10347,7 +9059,7 @@ class MalformedContentTypeWithoutBodyOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -10360,27 +9072,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_CONTENT_TYPE_WITHOUT_BODY = APIOperation( input=MalformedContentTypeWithoutBodyInput, output=MalformedContentTypeWithoutBodyOutput, - schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY, - input_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT, - output_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT, + static_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10392,17 +9100,15 @@ class MalformedContentTypeWithoutBodyEmptyInputInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT, self + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT + ).members_by_index if self.header is not None: - serializer.write_string( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT.members[ - "header" - ], - self.header, - ) + serializer.write_string(members[0], self.header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10411,23 +9117,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header"] = de.read_string( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT.members[ - "header" - ] - ) + kwargs["header"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10447,7 +9148,8 @@ class MalformedContentTypeWithoutBodyEmptyInputOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT), + self, ) def serialize_members(self, serializer: ShapeSerializer): @@ -10460,28 +9162,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT = APIOperation( input=MalformedContentTypeWithoutBodyEmptyInputInput, output=MalformedContentTypeWithoutBodyEmptyInputOutput, - schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT, - input_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT, - output_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10492,14 +9189,16 @@ class MalformedContentTypeWithPayloadInput: payload: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT + ).members_by_index if self.payload is not None: - serializer.write_blob( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT.members["payload"], - self.payload, - ) + serializer.write_blob(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10508,22 +9207,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_blob( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT.members[ - "payload" - ] - ) + kwargs["payload"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10543,7 +9238,7 @@ class MalformedContentTypeWithPayloadOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -10556,27 +9251,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_CONTENT_TYPE_WITH_PAYLOAD = APIOperation( input=MalformedContentTypeWithPayloadInput, output=MalformedContentTypeWithPayloadOutput, - schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD, - input_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT, - output_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_MALFORMED_CONTENT_TYPE_WITH_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10593,32 +9284,21 @@ class MalformedDoubleInput: double_in_header: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_DOUBLE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_DOUBLE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_DOUBLE_INPUT).members_by_index if self.double_in_body is not None: - serializer.write_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInBody"], - self.double_in_body, - ) + serializer.write_double(members[0], self.double_in_body) if self.double_in_path is not None: - serializer.write_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInPath"], - self.double_in_path, - ) + serializer.write_double(members[1], self.double_in_path) if self.double_in_query is not None: - serializer.write_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInQuery"], - self.double_in_query, - ) + serializer.write_double(members[2], self.double_in_query) if self.double_in_header is not None: - serializer.write_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInHeader"], - self.double_in_header, - ) + serializer.write_double(members[3], self.double_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10627,33 +9307,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_DOUBLE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["double_in_body"] = de.read_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInBody"] - ) + kwargs["double_in_body"] = de.read_double(members[0]) case 1: - kwargs["double_in_path"] = de.read_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInPath"] - ) + kwargs["double_in_path"] = de.read_double(members[1]) case 2: - kwargs["double_in_query"] = de.read_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInQuery"] - ) + kwargs["double_in_query"] = de.read_double(members[2]) case 3: - kwargs["double_in_header"] = de.read_double( - _SCHEMA_MALFORMED_DOUBLE_INPUT.members["doubleInHeader"] - ) + kwargs["double_in_header"] = de.read_double(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_DOUBLE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10672,7 +9346,7 @@ class MalformedDoubleOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_DOUBLE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_DOUBLE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -10684,25 +9358,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_DOUBLE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_DOUBLE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_DOUBLE = APIOperation( input=MalformedDoubleInput, output=MalformedDoubleOutput, - schema=_SCHEMA_MALFORMED_DOUBLE, - input_schema=_SCHEMA_MALFORMED_DOUBLE_INPUT, - output_schema=_SCHEMA_MALFORMED_DOUBLE_OUTPUT, + static_schema=_SCHEMA_MALFORMED_DOUBLE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10719,30 +9391,21 @@ class MalformedFloatInput: float_in_header: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_FLOAT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_FLOAT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_FLOAT_INPUT).members_by_index if self.float_in_body is not None: - serializer.write_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInBody"], self.float_in_body - ) + serializer.write_float(members[0], self.float_in_body) if self.float_in_path is not None: - serializer.write_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInPath"], self.float_in_path - ) + serializer.write_float(members[1], self.float_in_path) if self.float_in_query is not None: - serializer.write_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInQuery"], - self.float_in_query, - ) + serializer.write_float(members[2], self.float_in_query) if self.float_in_header is not None: - serializer.write_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInHeader"], - self.float_in_header, - ) + serializer.write_float(members[3], self.float_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10751,33 +9414,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_FLOAT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_in_body"] = de.read_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInBody"] - ) + kwargs["float_in_body"] = de.read_float(members[0]) case 1: - kwargs["float_in_path"] = de.read_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInPath"] - ) + kwargs["float_in_path"] = de.read_float(members[1]) case 2: - kwargs["float_in_query"] = de.read_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInQuery"] - ) + kwargs["float_in_query"] = de.read_float(members[2]) case 3: - kwargs["float_in_header"] = de.read_float( - _SCHEMA_MALFORMED_FLOAT_INPUT.members["floatInHeader"] - ) + kwargs["float_in_header"] = de.read_float(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_FLOAT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10796,7 +9453,7 @@ class MalformedFloatOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_FLOAT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_FLOAT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -10808,25 +9465,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_FLOAT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_FLOAT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_FLOAT = APIOperation( input=MalformedFloatInput, output=MalformedFloatOutput, - schema=_SCHEMA_MALFORMED_FLOAT, - input_schema=_SCHEMA_MALFORMED_FLOAT_INPUT, - output_schema=_SCHEMA_MALFORMED_FLOAT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_FLOAT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10843,32 +9498,21 @@ class MalformedIntegerInput: integer_in_header: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_INTEGER_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_INTEGER_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_INTEGER_INPUT).members_by_index if self.integer_in_body is not None: - serializer.write_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInBody"], - self.integer_in_body, - ) + serializer.write_integer(members[0], self.integer_in_body) if self.integer_in_path is not None: - serializer.write_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInPath"], - self.integer_in_path, - ) + serializer.write_integer(members[1], self.integer_in_path) if self.integer_in_query is not None: - serializer.write_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInQuery"], - self.integer_in_query, - ) + serializer.write_integer(members[2], self.integer_in_query) if self.integer_in_header is not None: - serializer.write_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInHeader"], - self.integer_in_header, - ) + serializer.write_integer(members[3], self.integer_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10877,33 +9521,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_INTEGER_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["integer_in_body"] = de.read_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInBody"] - ) + kwargs["integer_in_body"] = de.read_integer(members[0]) case 1: - kwargs["integer_in_path"] = de.read_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInPath"] - ) + kwargs["integer_in_path"] = de.read_integer(members[1]) case 2: - kwargs["integer_in_query"] = de.read_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInQuery"] - ) + kwargs["integer_in_query"] = de.read_integer(members[2]) case 3: - kwargs["integer_in_header"] = de.read_integer( - _SCHEMA_MALFORMED_INTEGER_INPUT.members["integerInHeader"] - ) + kwargs["integer_in_header"] = de.read_integer(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_INTEGER_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10922,7 +9560,7 @@ class MalformedIntegerOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_INTEGER_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_INTEGER_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -10934,32 +9572,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_INTEGER_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_INTEGER_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_INTEGER = APIOperation( input=MalformedIntegerInput, output=MalformedIntegerOutput, - schema=_SCHEMA_MALFORMED_INTEGER, - input_schema=_SCHEMA_MALFORMED_INTEGER_INPUT, - output_schema=_SCHEMA_MALFORMED_INTEGER_OUTPUT, + static_schema=_SCHEMA_MALFORMED_INTEGER, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_simple_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -10969,7 +9605,7 @@ def _deserialize_simple_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -10989,15 +9625,12 @@ class MalformedListInput: body_list: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_LIST_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_LIST_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_LIST_INPUT).members_by_index if self.body_list is not None: - _serialize_simple_list( - serializer, - _SCHEMA_MALFORMED_LIST_INPUT.members["bodyList"], - self.body_list, - ) + _serialize_simple_list(serializer, members[0], self.body_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11006,18 +9639,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_LIST_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["body_list"] = _deserialize_simple_list( - de, _SCHEMA_MALFORMED_LIST_INPUT.members["bodyList"] - ) + kwargs["body_list"] = _deserialize_simple_list(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_LIST_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11036,7 +9669,7 @@ class MalformedListOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_LIST_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_LIST_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11048,25 +9681,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_LIST_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_LIST_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_LIST = APIOperation( input=MalformedListInput, output=MalformedListOutput, - schema=_SCHEMA_MALFORMED_LIST, - input_schema=_SCHEMA_MALFORMED_LIST_INPUT, - output_schema=_SCHEMA_MALFORMED_LIST_OUTPUT, + static_schema=_SCHEMA_MALFORMED_LIST, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11083,29 +9714,21 @@ class MalformedLongInput: long_in_header: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_LONG_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_LONG_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_LONG_INPUT).members_by_index if self.long_in_body is not None: - serializer.write_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInBody"], self.long_in_body - ) + serializer.write_long(members[0], self.long_in_body) if self.long_in_path is not None: - serializer.write_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInPath"], self.long_in_path - ) + serializer.write_long(members[1], self.long_in_path) if self.long_in_query is not None: - serializer.write_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInQuery"], self.long_in_query - ) + serializer.write_long(members[2], self.long_in_query) if self.long_in_header is not None: - serializer.write_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInHeader"], - self.long_in_header, - ) + serializer.write_long(members[3], self.long_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11114,33 +9737,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_LONG_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["long_in_body"] = de.read_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInBody"] - ) + kwargs["long_in_body"] = de.read_long(members[0]) case 1: - kwargs["long_in_path"] = de.read_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInPath"] - ) + kwargs["long_in_path"] = de.read_long(members[1]) case 2: - kwargs["long_in_query"] = de.read_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInQuery"] - ) + kwargs["long_in_query"] = de.read_long(members[2]) case 3: - kwargs["long_in_header"] = de.read_long( - _SCHEMA_MALFORMED_LONG_INPUT.members["longInHeader"] - ) + kwargs["long_in_header"] = de.read_long(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_LONG_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11159,7 +9776,7 @@ class MalformedLongOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_LONG_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_LONG_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11171,25 +9788,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_LONG_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_LONG_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_LONG = APIOperation( input=MalformedLongInput, output=MalformedLongOutput, - schema=_SCHEMA_MALFORMED_LONG, - input_schema=_SCHEMA_MALFORMED_LONG_INPUT, - output_schema=_SCHEMA_MALFORMED_LONG_OUTPUT, + static_schema=_SCHEMA_MALFORMED_LONG, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11197,7 +9812,7 @@ def _serialize_simple_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -11206,7 +9821,7 @@ def _deserialize_simple_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -11226,15 +9841,12 @@ class MalformedMapInput: body_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_MAP_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_MAP_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_MAP_INPUT).members_by_index if self.body_map is not None: - _serialize_simple_map( - serializer, - _SCHEMA_MALFORMED_MAP_INPUT.members["bodyMap"], - self.body_map, - ) + _serialize_simple_map(serializer, members[0], self.body_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11243,18 +9855,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_MAP_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["body_map"] = _deserialize_simple_map( - de, _SCHEMA_MALFORMED_MAP_INPUT.members["bodyMap"] - ) + kwargs["body_map"] = _deserialize_simple_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_MAP_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11273,7 +9885,7 @@ class MalformedMapOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_MAP_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_MAP_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11285,25 +9897,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_MAP_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_MAP_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_MAP = APIOperation( input=MalformedMapInput, output=MalformedMapOutput, - schema=_SCHEMA_MALFORMED_MAP, - input_schema=_SCHEMA_MALFORMED_MAP_INPUT, - output_schema=_SCHEMA_MALFORMED_MAP_OUTPUT, + static_schema=_SCHEMA_MALFORMED_MAP, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11316,18 +9926,15 @@ class MalformedRequestBodyInput: float_: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_REQUEST_BODY_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_REQUEST_BODY_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_REQUEST_BODY_INPUT).members_by_index if self.int_ is not None: - serializer.write_integer( - _SCHEMA_MALFORMED_REQUEST_BODY_INPUT.members["int"], self.int_ - ) + serializer.write_integer(members[0], self.int_) if self.float_ is not None: - serializer.write_float( - _SCHEMA_MALFORMED_REQUEST_BODY_INPUT.members["float"], self.float_ - ) + serializer.write_float(members[1], self.float_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11336,25 +9943,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_REQUEST_BODY_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_"] = de.read_integer( - _SCHEMA_MALFORMED_REQUEST_BODY_INPUT.members["int"] - ) + kwargs["int_"] = de.read_integer(members[0]) case 1: - kwargs["float_"] = de.read_float( - _SCHEMA_MALFORMED_REQUEST_BODY_INPUT.members["float"] - ) + kwargs["float_"] = de.read_float(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_REQUEST_BODY_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11373,7 +9976,7 @@ class MalformedRequestBodyOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_REQUEST_BODY_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_REQUEST_BODY_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11385,27 +9988,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_REQUEST_BODY_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_REQUEST_BODY_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_REQUEST_BODY = APIOperation( input=MalformedRequestBodyInput, output=MalformedRequestBodyOutput, - schema=_SCHEMA_MALFORMED_REQUEST_BODY, - input_schema=_SCHEMA_MALFORMED_REQUEST_BODY_INPUT, - output_schema=_SCHEMA_MALFORMED_REQUEST_BODY_OUTPUT, + static_schema=_SCHEMA_MALFORMED_REQUEST_BODY, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11422,30 +10021,21 @@ class MalformedShortInput: short_in_header: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_SHORT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_SHORT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_SHORT_INPUT).members_by_index if self.short_in_body is not None: - serializer.write_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInBody"], self.short_in_body - ) + serializer.write_short(members[0], self.short_in_body) if self.short_in_path is not None: - serializer.write_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInPath"], self.short_in_path - ) + serializer.write_short(members[1], self.short_in_path) if self.short_in_query is not None: - serializer.write_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInQuery"], - self.short_in_query, - ) + serializer.write_short(members[2], self.short_in_query) if self.short_in_header is not None: - serializer.write_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInHeader"], - self.short_in_header, - ) + serializer.write_short(members[3], self.short_in_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11454,33 +10044,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_SHORT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["short_in_body"] = de.read_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInBody"] - ) + kwargs["short_in_body"] = de.read_short(members[0]) case 1: - kwargs["short_in_path"] = de.read_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInPath"] - ) + kwargs["short_in_path"] = de.read_short(members[1]) case 2: - kwargs["short_in_query"] = de.read_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInQuery"] - ) + kwargs["short_in_query"] = de.read_short(members[2]) case 3: - kwargs["short_in_header"] = de.read_short( - _SCHEMA_MALFORMED_SHORT_INPUT.members["shortInHeader"] - ) + kwargs["short_in_header"] = de.read_short(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_SHORT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11499,7 +10083,7 @@ class MalformedShortOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_SHORT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_SHORT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11511,25 +10095,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_SHORT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_SHORT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_SHORT = APIOperation( input=MalformedShortInput, output=MalformedShortOutput, - schema=_SCHEMA_MALFORMED_SHORT, - input_schema=_SCHEMA_MALFORMED_SHORT_INPUT, - output_schema=_SCHEMA_MALFORMED_SHORT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_SHORT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11540,13 +10122,12 @@ class MalformedStringInput: blob: str | JsonString | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_STRING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_STRING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_STRING_INPUT).members_by_index if self.blob is not None: - serializer.write_string( - _SCHEMA_MALFORMED_STRING_INPUT.members["blob"], self.blob - ) + serializer.write_string(members[0], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11555,18 +10136,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["blob"] = de.read_string( - _SCHEMA_MALFORMED_STRING_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_STRING_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11585,7 +10166,7 @@ class MalformedStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_STRING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_STRING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11597,25 +10178,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_STRING_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_STRING = APIOperation( input=MalformedStringInput, output=MalformedStringOutput, - schema=_SCHEMA_MALFORMED_STRING, - input_schema=_SCHEMA_MALFORMED_STRING_INPUT, - output_schema=_SCHEMA_MALFORMED_STRING_OUTPUT, + static_schema=_SCHEMA_MALFORMED_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11626,14 +10205,16 @@ class MalformedTimestampBodyDateTimeInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11642,22 +10223,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11676,7 +10253,9 @@ class MalformedTimestampBodyDateTimeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11688,27 +10267,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_BODY_DATE_TIME = APIOperation( input=MalformedTimestampBodyDateTimeInput, output=MalformedTimestampBodyDateTimeOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DATE_TIME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11719,14 +10294,16 @@ class MalformedTimestampBodyDefaultInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11735,22 +10312,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11769,7 +10342,9 @@ class MalformedTimestampBodyDefaultOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11781,27 +10356,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_BODY_DEFAULT = APIOperation( input=MalformedTimestampBodyDefaultInput, output=MalformedTimestampBodyDefaultOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_DEFAULT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11812,14 +10383,16 @@ class MalformedTimestampBodyHttpDateInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11828,22 +10401,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11862,7 +10431,9 @@ class MalformedTimestampBodyHttpDateOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -11874,27 +10445,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_BODY_HTTP_DATE = APIOperation( input=MalformedTimestampBodyHttpDateInput, output=MalformedTimestampBodyHttpDateOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_BODY_HTTP_DATE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -11906,15 +10473,15 @@ class MalformedTimestampHeaderDateTimeInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT, self + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11923,22 +10490,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11958,7 +10521,7 @@ class MalformedTimestampHeaderDateTimeOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -11971,27 +10534,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_HEADER_DATE_TIME = APIOperation( input=MalformedTimestampHeaderDateTimeInput, output=MalformedTimestampHeaderDateTimeOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DATE_TIME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12002,14 +10561,16 @@ class MalformedTimestampHeaderDefaultInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12018,22 +10579,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12052,7 +10609,9 @@ class MalformedTimestampHeaderDefaultOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12064,27 +10623,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_HEADER_DEFAULT = APIOperation( input=MalformedTimestampHeaderDefaultInput, output=MalformedTimestampHeaderDefaultOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_DEFAULT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12095,14 +10650,16 @@ class MalformedTimestampHeaderEpochInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12111,22 +10668,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12145,7 +10698,9 @@ class MalformedTimestampHeaderEpochOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12157,27 +10712,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_HEADER_EPOCH = APIOperation( input=MalformedTimestampHeaderEpochInput, output=MalformedTimestampHeaderEpochOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_HEADER_EPOCH, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12188,14 +10739,16 @@ class MalformedTimestampPathDefaultInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12204,22 +10757,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12238,7 +10787,9 @@ class MalformedTimestampPathDefaultOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12250,27 +10801,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_PATH_DEFAULT = APIOperation( input=MalformedTimestampPathDefaultInput, output=MalformedTimestampPathDefaultOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_DEFAULT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12281,14 +10828,14 @@ class MalformedTimestampPathEpochInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12297,22 +10844,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12331,7 +10874,9 @@ class MalformedTimestampPathEpochOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12343,27 +10888,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_PATH_EPOCH = APIOperation( input=MalformedTimestampPathEpochInput, output=MalformedTimestampPathEpochOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_EPOCH, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12374,14 +10915,16 @@ class MalformedTimestampPathHttpDateInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12390,22 +10933,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12424,7 +10963,9 @@ class MalformedTimestampPathHttpDateOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12436,27 +10977,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_PATH_HTTP_DATE = APIOperation( input=MalformedTimestampPathHttpDateInput, output=MalformedTimestampPathHttpDateOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_PATH_HTTP_DATE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12467,14 +11004,16 @@ class MalformedTimestampQueryDefaultInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12483,22 +11022,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12517,7 +11052,9 @@ class MalformedTimestampQueryDefaultOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12529,27 +11066,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_QUERY_DEFAULT = APIOperation( input=MalformedTimestampQueryDefaultInput, output=MalformedTimestampQueryDefaultOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_DEFAULT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12560,14 +11093,16 @@ class MalformedTimestampQueryEpochInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12576,22 +11111,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12610,7 +11141,9 @@ class MalformedTimestampQueryEpochOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12622,27 +11155,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_QUERY_EPOCH = APIOperation( input=MalformedTimestampQueryEpochInput, output=MalformedTimestampQueryEpochOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_EPOCH, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12653,14 +11182,16 @@ class MalformedTimestampQueryHttpDateInput: timestamp: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT + ).members_by_index if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[0], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12669,22 +11200,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT.members[ - "timestamp" - ] - ) + kwargs["timestamp"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12704,7 +11231,7 @@ class MalformedTimestampQueryHttpDateOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT, self + hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -12717,27 +11244,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_TIMESTAMP_QUERY_HTTP_DATE = APIOperation( input=MalformedTimestampQueryHttpDateInput, output=MalformedTimestampQueryHttpDateOutput, - schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE, - input_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT, - output_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT, + static_schema=_SCHEMA_MALFORMED_TIMESTAMP_QUERY_HTTP_DATE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12746,14 +11269,16 @@ class SimpleUnionInt: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer(_SCHEMA_SIMPLE_UNION.members["int"], self.value) + members = hydrate(_SCHEMA_SIMPLE_UNION).members_by_index + serializer.write_integer(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls(value=deserializer.read_integer(_SCHEMA_SIMPLE_UNION.members["int"])) + members = hydrate(_SCHEMA_SIMPLE_UNION).members_by_index + return cls(value=deserializer.read_integer(members[0])) @dataclass @@ -12761,16 +11286,16 @@ class SimpleUnionString: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_SIMPLE_UNION.members["string"], self.value) + members = hydrate(_SCHEMA_SIMPLE_UNION).members_by_index + serializer.write_string(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_SIMPLE_UNION.members["string"]) - ) + members = hydrate(_SCHEMA_SIMPLE_UNION).members_by_index + return cls(value=deserializer.read_string(members[1])) @dataclass @@ -12805,7 +11330,7 @@ class _SimpleUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> SimpleUnion: self._result = None - deserializer.read_struct(_SCHEMA_SIMPLE_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_SIMPLE_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -12840,13 +11365,12 @@ class MalformedUnionInput: union: SimpleUnion | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_UNION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_UNION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MALFORMED_UNION_INPUT).members_by_index if self.union is not None: - serializer.write_struct( - _SCHEMA_MALFORMED_UNION_INPUT.members["union"], self.union - ) + serializer.write_struct(members[0], self.union) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12855,16 +11379,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_UNION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["union"] = _SimpleUnionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_UNION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12883,7 +11409,7 @@ class MalformedUnionOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MALFORMED_UNION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MALFORMED_UNION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -12895,25 +11421,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MALFORMED_UNION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MALFORMED_UNION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MALFORMED_UNION = APIOperation( input=MalformedUnionInput, output=MalformedUnionOutput, - schema=_SCHEMA_MALFORMED_UNION, - input_schema=_SCHEMA_MALFORMED_UNION_INPUT, - output_schema=_SCHEMA_MALFORMED_UNION_OUTPUT, + static_schema=_SCHEMA_MALFORMED_UNION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -12924,13 +11448,12 @@ class MediaTypeHeaderInput: json: str | JsonString | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MEDIA_TYPE_HEADER_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MEDIA_TYPE_HEADER_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MEDIA_TYPE_HEADER_INPUT).members_by_index if self.json is not None: - serializer.write_string( - _SCHEMA_MEDIA_TYPE_HEADER_INPUT.members["json"], self.json - ) + serializer.write_string(members[0], self.json) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12939,18 +11462,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MEDIA_TYPE_HEADER_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["json"] = de.read_string( - _SCHEMA_MEDIA_TYPE_HEADER_INPUT.members["json"] - ) + kwargs["json"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MEDIA_TYPE_HEADER_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -12971,13 +11494,12 @@ class MediaTypeHeaderOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_MEDIA_TYPE_HEADER_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_MEDIA_TYPE_HEADER_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_MEDIA_TYPE_HEADER_OUTPUT).members_by_index if self.json is not None: - serializer.write_string( - _SCHEMA_MEDIA_TYPE_HEADER_OUTPUT.members["json"], self.json - ) + serializer.write_string(members[0], self.json) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -12986,30 +11508,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_MEDIA_TYPE_HEADER_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["json"] = de.read_string( - _SCHEMA_MEDIA_TYPE_HEADER_OUTPUT.members["json"] - ) + kwargs["json"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_MEDIA_TYPE_HEADER_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs MEDIA_TYPE_HEADER = APIOperation( input=MediaTypeHeaderInput, output=MediaTypeHeaderOutput, - schema=_SCHEMA_MEDIA_TYPE_HEADER, - input_schema=_SCHEMA_MEDIA_TYPE_HEADER_INPUT, - output_schema=_SCHEMA_MEDIA_TYPE_HEADER_OUTPUT, + static_schema=_SCHEMA_MEDIA_TYPE_HEADER, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13018,7 +11537,7 @@ class NoInputAndNoOutputInput: """Dataclass for NoInputAndNoOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -13030,15 +11549,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13057,7 +11575,7 @@ class NoInputAndNoOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -13069,27 +11587,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_NO_OUTPUT = APIOperation( input=NoInputAndNoOutputInput, output=NoInputAndNoOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13098,7 +11612,7 @@ class NoInputAndOutputInput: """Dataclass for NoInputAndOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -13110,13 +11624,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13135,7 +11650,7 @@ class NoInputAndOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -13147,25 +11662,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_OUTPUT = APIOperation( input=NoInputAndOutputInput, output=NoInputAndOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13180,25 +11693,20 @@ class NullAndEmptyHeadersClientInput: c: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13207,30 +11715,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13255,25 +11757,20 @@ class NullAndEmptyHeadersClientOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13282,42 +11779,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NULL_AND_EMPTY_HEADERS_CLIENT = APIOperation( input=NullAndEmptyHeadersClientInput, output=NullAndEmptyHeadersClientOutput, - schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT, - input_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, - output_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, + static_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13332,25 +11820,20 @@ class NullAndEmptyHeadersServerInput: c: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13359,30 +11842,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13407,25 +11884,20 @@ class NullAndEmptyHeadersServerOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13434,42 +11906,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NULL_AND_EMPTY_HEADERS_SERVER = APIOperation( input=NullAndEmptyHeadersServerInput, output=NullAndEmptyHeadersServerOutput, - schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER, - input_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT, - output_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, + static_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13482,20 +11945,19 @@ class OmitsNullSerializesEmptyStringInput: empty_string: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT + ).members_by_index if self.null_value is not None: - serializer.write_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members["nullValue"], - self.null_value, - ) + serializer.write_string(members[0], self.null_value) if self.empty_string is not None: - serializer.write_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members["emptyString"], - self.empty_string, - ) + serializer.write_string(members[1], self.empty_string) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13504,29 +11966,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["null_value"] = de.read_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members[ - "nullValue" - ] - ) + kwargs["null_value"] = de.read_string(members[0]) case 1: - kwargs["empty_string"] = de.read_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members[ - "emptyString" - ] - ) + kwargs["empty_string"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13545,7 +11999,9 @@ class OmitsNullSerializesEmptyStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -13557,27 +12013,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OMITS_NULL_SERIALIZES_EMPTY_STRING = APIOperation( input=OmitsNullSerializesEmptyStringInput, output=OmitsNullSerializesEmptyStringOutput, - schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING, - input_schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, - output_schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, + static_schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13600,60 +12052,33 @@ class OmitsSerializingEmptyListsInput: query_integer_enum_list: list[int] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT).members_by_index if self.query_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members["queryStringList"], - self.query_string_list, - ) + _serialize_string_list(serializer, members[0], self.query_string_list) if self.query_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members["queryIntegerList"], - self.query_integer_list, - ) + _serialize_integer_list(serializer, members[1], self.query_integer_list) if self.query_double_list is not None: - _serialize_double_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members["queryDoubleList"], - self.query_double_list, - ) + _serialize_double_list(serializer, members[2], self.query_double_list) if self.query_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members["queryBooleanList"], - self.query_boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.query_boolean_list) if self.query_timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryTimestampList" - ], - self.query_timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.query_timestamp_list) if self.query_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members["queryEnumList"], - self.query_enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.query_enum_list) if self.query_integer_enum_list is not None: _serialize_integer_enum_list( - serializer, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryIntegerEnumList" - ], - self.query_integer_enum_list, + serializer, members[6], self.query_integer_enum_list ) @classmethod @@ -13663,71 +12088,50 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["query_string_list"] = _deserialize_string_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryStringList" - ], + de, members[0] ) case 1: kwargs["query_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryIntegerList" - ], + de, members[1] ) case 2: kwargs["query_double_list"] = _deserialize_double_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryDoubleList" - ], + de, members[2] ) case 3: kwargs["query_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryBooleanList" - ], + de, members[3] ) case 4: kwargs["query_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryTimestampList" - ], + de, members[4] ) case 5: kwargs["query_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryEnumList" - ], + de, members[5] ) case 6: kwargs["query_integer_enum_list"] = _deserialize_integer_enum_list( - de, - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT.members[ - "queryIntegerEnumList" - ], + de, members[6] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13746,7 +12150,9 @@ class OmitsSerializingEmptyListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -13758,27 +12164,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OMITS_SERIALIZING_EMPTY_LISTS = APIOperation( input=OmitsSerializingEmptyListsInput, output=OmitsSerializingEmptyListsOutput, - schema=_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS, - input_schema=_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_INPUT, - output_schema=_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT, + static_schema=_SCHEMA_OMITS_SERIALIZING_EMPTY_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -13795,31 +12197,21 @@ class OperationWithDefaultsInput: other_top_level_default: int = 0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT).members_by_index if self.defaults is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["defaults"], self.defaults - ) + serializer.write_struct(members[0], self.defaults) if self.client_optional_defaults is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["clientOptionalDefaults"], - self.client_optional_defaults, - ) + serializer.write_struct(members[1], self.client_optional_defaults) if self.top_level_default is not None: - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["topLevelDefault"], - self.top_level_default, - ) + serializer.write_string(members[2], self.top_level_default) if self.other_top_level_default is not None: - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["otherTopLevelDefault"], - self.other_top_level_default, - ) + serializer.write_integer(members[3], self.other_top_level_default) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -13828,9 +12220,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["defaults"] = Defaults.deserialize(de) @@ -13840,23 +12234,15 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case 2: - kwargs["top_level_default"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["topLevelDefault"] - ) + kwargs["top_level_default"] = de.read_string(members[2]) case 3: - kwargs["other_top_level_default"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members[ - "otherTopLevelDefault" - ] - ) + kwargs["other_top_level_default"] = de.read_integer(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -13931,118 +12317,38 @@ class OperationWithDefaultsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultString"], - self.default_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBoolean"], - self.default_boolean, - ) - _serialize_test_string_list( - serializer, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultList"], - self.default_list, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentMap"], - self.default_document_map, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentString"], - self.default_document_string, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentBoolean"], - self.default_document_boolean, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDocumentList"], - self.default_document_list, - ) - serializer.write_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultNullDocument"], - self.default_null_document, - ) - serializer.write_timestamp( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultTimestamp"], - self.default_timestamp, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBlob"], - self.default_blob, - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultByte"], - self.default_byte, - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultShort"], - self.default_short, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultInteger"], - self.default_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultLong"], - self.default_long, - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultFloat"], - self.default_float, - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDouble"], - self.default_double, - ) - _serialize_test_string_map( - serializer, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultMap"], - self.default_map, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultEnum"], - self.default_enum, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultIntEnum"], - self.default_int_enum, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyString"], - self.empty_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["falseBoolean"], - self.false_boolean, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyBlob"], self.empty_blob - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroByte"], self.zero_byte - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroShort"], self.zero_short - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroInteger"], - self.zero_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroLong"], self.zero_long - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroFloat"], self.zero_float - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroDouble"], - self.zero_double, - ) + members = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT).members_by_index + serializer.write_string(members[0], self.default_string) + serializer.write_boolean(members[1], self.default_boolean) + _serialize_test_string_list(serializer, members[2], self.default_list) + serializer.write_document(members[3], self.default_document_map) + serializer.write_document(members[4], self.default_document_string) + serializer.write_document(members[5], self.default_document_boolean) + serializer.write_document(members[6], self.default_document_list) + serializer.write_document(members[7], self.default_null_document) + serializer.write_timestamp(members[8], self.default_timestamp) + serializer.write_blob(members[9], self.default_blob) + serializer.write_byte(members[10], self.default_byte) + serializer.write_short(members[11], self.default_short) + serializer.write_integer(members[12], self.default_integer) + serializer.write_long(members[13], self.default_long) + serializer.write_float(members[14], self.default_float) + serializer.write_double(members[15], self.default_double) + _serialize_test_string_map(serializer, members[16], self.default_map) + serializer.write_string(members[17], self.default_enum) + serializer.write_integer(members[18], self.default_int_enum) + serializer.write_string(members[19], self.empty_string) + serializer.write_boolean(members[20], self.false_boolean) + serializer.write_blob(members[21], self.empty_blob) + serializer.write_byte(members[22], self.zero_byte) + serializer.write_short(members[23], self.zero_short) + serializer.write_integer(members[24], self.zero_integer) + serializer.write_long(members[25], self.zero_long) + serializer.write_float(members[26], self.zero_float) + serializer.write_double(members[27], self.zero_double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14051,188 +12357,114 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["default_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultString"] - ) + kwargs["default_string"] = de.read_string(members[0]) case 1: - kwargs["default_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBoolean"] - ) + kwargs["default_boolean"] = de.read_boolean(members[1]) case 2: kwargs["default_list"] = _deserialize_test_string_list( - de, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultList"], + de, members[2] ) case 3: - kwargs["default_document_map"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentMap" - ] - ) + kwargs["default_document_map"] = de.read_document(members[3]) case 4: - kwargs["default_document_string"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentString" - ] - ) + kwargs["default_document_string"] = de.read_document(members[4]) case 5: - kwargs["default_document_boolean"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentBoolean" - ] - ) + kwargs["default_document_boolean"] = de.read_document(members[5]) case 6: - kwargs["default_document_list"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultDocumentList" - ] - ) + kwargs["default_document_list"] = de.read_document(members[6]) case 7: - kwargs["default_null_document"] = de.read_document( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultNullDocument" - ] - ) + kwargs["default_null_document"] = de.read_document(members[7]) case 8: - kwargs["default_timestamp"] = de.read_timestamp( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultTimestamp" - ] - ) + kwargs["default_timestamp"] = de.read_timestamp(members[8]) case 9: - kwargs["default_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBlob"] - ) + kwargs["default_blob"] = de.read_blob(members[9]) case 10: - kwargs["default_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultByte"] - ) + kwargs["default_byte"] = de.read_byte(members[10]) case 11: - kwargs["default_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultShort"] - ) + kwargs["default_short"] = de.read_short(members[11]) case 12: - kwargs["default_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultInteger"] - ) + kwargs["default_integer"] = de.read_integer(members[12]) case 13: - kwargs["default_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultLong"] - ) + kwargs["default_long"] = de.read_long(members[13]) case 14: - kwargs["default_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultFloat"] - ) + kwargs["default_float"] = de.read_float(members[14]) case 15: - kwargs["default_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDouble"] - ) + kwargs["default_double"] = de.read_double(members[15]) case 16: kwargs["default_map"] = _deserialize_test_string_map( - de, _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultMap"] + de, members[16] ) case 17: - kwargs["default_enum"] = TestEnum( - de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultEnum" - ] - ) - ) + kwargs["default_enum"] = TestEnum(de.read_string(members[17])) case 18: kwargs["default_int_enum"] = TestIntEnum( - de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultIntEnum" - ] - ) + de.read_integer(members[18]) ) case 19: - kwargs["empty_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[19]) case 20: - kwargs["false_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["falseBoolean"] - ) + kwargs["false_boolean"] = de.read_boolean(members[20]) case 21: - kwargs["empty_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyBlob"] - ) + kwargs["empty_blob"] = de.read_blob(members[21]) case 22: - kwargs["zero_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroByte"] - ) + kwargs["zero_byte"] = de.read_byte(members[22]) case 23: - kwargs["zero_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroShort"] - ) + kwargs["zero_short"] = de.read_short(members[23]) case 24: - kwargs["zero_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroInteger"] - ) + kwargs["zero_integer"] = de.read_integer(members[24]) case 25: - kwargs["zero_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroLong"] - ) + kwargs["zero_long"] = de.read_long(members[25]) case 26: - kwargs["zero_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroFloat"] - ) + kwargs["zero_float"] = de.read_float(members[26]) case 27: - kwargs["zero_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroDouble"] - ) + kwargs["zero_double"] = de.read_double(members[27]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OPERATION_WITH_DEFAULTS = APIOperation( input=OperationWithDefaultsInput, output=OperationWithDefaultsOutput, - schema=_SCHEMA_OPERATION_WITH_DEFAULTS, - input_schema=_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_DEFAULTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -14247,16 +12479,13 @@ class TopLevel: dialog_map: dict[str, Dialog] = field(default_factory=dict[str, Dialog]) def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOP_LEVEL, self) + serializer.write_struct(hydrate(_SCHEMA_TOP_LEVEL), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TOP_LEVEL.members["dialog"], self.dialog) - _serialize_dialog_list( - serializer, _SCHEMA_TOP_LEVEL.members["dialogList"], self.dialog_list - ) - _serialize_dialog_map( - serializer, _SCHEMA_TOP_LEVEL.members["dialogMap"], self.dialog_map - ) + members = hydrate(_SCHEMA_TOP_LEVEL).members_by_index + serializer.write_struct(members[0], self.dialog) + _serialize_dialog_list(serializer, members[1], self.dialog_list) + _serialize_dialog_map(serializer, members[2], self.dialog_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14265,26 +12494,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TOP_LEVEL) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dialog"] = Dialog.deserialize(de) case 1: - kwargs["dialog_list"] = _deserialize_dialog_list( - de, _SCHEMA_TOP_LEVEL.members["dialogList"] - ) + kwargs["dialog_list"] = _deserialize_dialog_list(de, members[1]) case 2: - kwargs["dialog_map"] = _deserialize_dialog_map( - de, _SCHEMA_TOP_LEVEL.members["dialogMap"] - ) + kwargs["dialog_map"] = _deserialize_dialog_map(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TOP_LEVEL, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "dialog" not in kwargs: kwargs["dialog"] = Dialog._smithy_default() return kwargs @@ -14297,14 +12524,16 @@ class OperationWithNestedStructureInput: top_level: TopLevel | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT + ).members_by_index if self.top_level is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT.members["topLevel"], - self.top_level, - ) + serializer.write_struct(members[0], self.top_level) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14313,18 +12542,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["top_level"] = TopLevel.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14349,24 +12578,18 @@ class OperationWithNestedStructureOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, self) - - def serialize_members(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members["dialog"], - self.dialog, - ) - _serialize_dialog_list( - serializer, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members["dialogList"], - self.dialog_list, - ) - _serialize_dialog_map( - serializer, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members["dialogMap"], - self.dialog_map, + hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT), self ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT + ).members_by_index + serializer.write_struct(members[0], self.dialog) + _serialize_dialog_list(serializer, members[1], self.dialog_list) + _serialize_dialog_map(serializer, members[2], self.dialog_map) + @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: return cls(**cls.deserialize_kwargs(deserializer)) @@ -14374,34 +12597,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dialog"] = Dialog.deserialize(de) case 1: - kwargs["dialog_list"] = _deserialize_dialog_list( - de, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members[ - "dialogList" - ], - ) + kwargs["dialog_list"] = _deserialize_dialog_list(de, members[1]) case 2: - kwargs["dialog_map"] = _deserialize_dialog_map( - de, - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT.members[ - "dialogMap" - ], - ) + kwargs["dialog_map"] = _deserialize_dialog_map(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "dialog" not in kwargs: kwargs["dialog"] = Dialog._smithy_default() return kwargs @@ -14410,12 +12623,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: OPERATION_WITH_NESTED_STRUCTURE = APIOperation( input=OperationWithNestedStructureInput, output=OperationWithNestedStructureOutput, - schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE, - input_schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_NESTED_STRUCTURE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -14424,7 +12634,7 @@ class OutputStreamInput: """Dataclass for OutputStreamInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OUTPUT_STREAM_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OUTPUT_STREAM_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -14436,13 +12646,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OUTPUT_STREAM_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_OUTPUT_STREAM_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14461,7 +12672,7 @@ class OutputStreamOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OUTPUT_STREAM_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OUTPUT_STREAM_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -14473,22 +12684,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OUTPUT_STREAM_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_OUTPUT_STREAM_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OUTPUT_STREAM = APIOperation( input=OutputStreamInput, output=OutputStreamOutput, - schema=_SCHEMA_OUTPUT_STREAM, - input_schema=_SCHEMA_OUTPUT_STREAM_INPUT, - output_schema=_SCHEMA_OUTPUT_STREAM_OUTPUT, + static_schema=_SCHEMA_OUTPUT_STREAM, error_registry=TypeRegistry( { ShapeID( @@ -14497,7 +12707,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_SERVICE_UNAVAILABLE_ERROR], ) @@ -14506,7 +12715,9 @@ class OutputStreamWithInitialResponseInput: """Dataclass for OutputStreamWithInitialResponseInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -14518,15 +12729,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14548,16 +12758,14 @@ class OutputStreamWithInitialResponseOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT, self + hydrate(_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT.members[ - "initialResponseMember" - ], - self.initial_response_member, - ) + members = hydrate( + _SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT + ).members_by_index + serializer.write_string(members[0], self.initial_response_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14566,22 +12774,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["initial_response_member"] = de.read_string( - _SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT.members[ - "initialResponseMember" - ] - ) + kwargs["initial_response_member"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "initial_response_member" not in kwargs: kwargs["initial_response_member"] = "" return kwargs @@ -14590,12 +12794,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: OUTPUT_STREAM_WITH_INITIAL_RESPONSE = APIOperation( input=OutputStreamWithInitialResponseInput, output=OutputStreamWithInitialResponseOutput, - schema=_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE, - input_schema=_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT, - output_schema=_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT, + static_schema=_SCHEMA_OUTPUT_STREAM_WITH_INITIAL_RESPONSE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -14606,11 +12807,12 @@ class PayloadConfig: data: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_CONFIG, self) + serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_CONFIG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PAYLOAD_CONFIG).members_by_index if self.data is not None: - serializer.write_integer(_SCHEMA_PAYLOAD_CONFIG.members["data"], self.data) + serializer.write_integer(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14619,18 +12821,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PAYLOAD_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_integer( - _SCHEMA_PAYLOAD_CONFIG.members["data"] - ) + kwargs["data"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PAYLOAD_CONFIG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14639,7 +12841,7 @@ class Unit: """Dataclass for Unit structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNIT, self) + serializer.write_struct(hydrate(_SCHEMA_UNIT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -14651,13 +12853,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_UNIT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_UNIT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14668,10 +12871,11 @@ class PlayerActionQuit: value: Unit def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PLAYER_ACTION, self) + serializer.write_struct(hydrate(_SCHEMA_PLAYER_ACTION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PLAYER_ACTION.members["quit"], self.value) + members = hydrate(_SCHEMA_PLAYER_ACTION).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14710,7 +12914,7 @@ class _PlayerActionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> PlayerAction: self._result = None - deserializer.read_struct(_SCHEMA_PLAYER_ACTION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_PLAYER_ACTION), self._consumer) if self._result is None: raise SerializationError( @@ -14742,13 +12946,12 @@ class PostPlayerActionInput: action: PlayerAction | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_POST_PLAYER_ACTION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_POST_PLAYER_ACTION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_POST_PLAYER_ACTION_INPUT).members_by_index if self.action is not None: - serializer.write_struct( - _SCHEMA_POST_PLAYER_ACTION_INPUT.members["action"], self.action - ) + serializer.write_struct(members[0], self.action) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14757,16 +12960,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_POST_PLAYER_ACTION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["action"] = _PlayerActionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_POST_PLAYER_ACTION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -14787,12 +12992,11 @@ class PostPlayerActionOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_POST_PLAYER_ACTION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_POST_PLAYER_ACTION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_POST_PLAYER_ACTION_OUTPUT.members["action"], self.action - ) + members = hydrate(_SCHEMA_POST_PLAYER_ACTION_OUTPUT).members_by_index + serializer.write_struct(members[0], self.action) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14801,16 +13005,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_POST_PLAYER_ACTION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["action"] = _PlayerActionDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_POST_PLAYER_ACTION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "action" not in kwargs: kwargs["action"] = PlayerActionUnknown(tag="") return kwargs @@ -14819,12 +13025,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: POST_PLAYER_ACTION = APIOperation( input=PostPlayerActionInput, output=PostPlayerActionOutput, - schema=_SCHEMA_POST_PLAYER_ACTION, - input_schema=_SCHEMA_POST_PLAYER_ACTION_INPUT, - output_schema=_SCHEMA_POST_PLAYER_ACTION_OUTPUT, + static_schema=_SCHEMA_POST_PLAYER_ACTION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -14833,16 +13036,16 @@ class UnionWithJsonNameFoo: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNION_WITH_JSON_NAME, self) + serializer.write_struct(hydrate(_SCHEMA_UNION_WITH_JSON_NAME), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_UNION_WITH_JSON_NAME.members["foo"], self.value) + members = hydrate(_SCHEMA_UNION_WITH_JSON_NAME).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_UNION_WITH_JSON_NAME.members["foo"]) - ) + members = hydrate(_SCHEMA_UNION_WITH_JSON_NAME).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -14850,16 +13053,16 @@ class UnionWithJsonNameBar: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNION_WITH_JSON_NAME, self) + serializer.write_struct(hydrate(_SCHEMA_UNION_WITH_JSON_NAME), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_UNION_WITH_JSON_NAME.members["bar"], self.value) + members = hydrate(_SCHEMA_UNION_WITH_JSON_NAME).members_by_index + serializer.write_string(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_UNION_WITH_JSON_NAME.members["bar"]) - ) + members = hydrate(_SCHEMA_UNION_WITH_JSON_NAME).members_by_index + return cls(value=deserializer.read_string(members[1])) @dataclass @@ -14867,16 +13070,16 @@ class UnionWithJsonNameBaz: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNION_WITH_JSON_NAME, self) + serializer.write_struct(hydrate(_SCHEMA_UNION_WITH_JSON_NAME), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_UNION_WITH_JSON_NAME.members["baz"], self.value) + members = hydrate(_SCHEMA_UNION_WITH_JSON_NAME).members_by_index + serializer.write_string(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_UNION_WITH_JSON_NAME.members["baz"]) - ) + members = hydrate(_SCHEMA_UNION_WITH_JSON_NAME).members_by_index + return cls(value=deserializer.read_string(members[2])) @dataclass @@ -14916,7 +13119,7 @@ class _UnionWithJsonNameDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> UnionWithJsonName: self._result = None - deserializer.read_struct(_SCHEMA_UNION_WITH_JSON_NAME, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_UNION_WITH_JSON_NAME), self._consumer) if self._result is None: raise SerializationError( @@ -14956,13 +13159,12 @@ class PostUnionWithJsonNameInput: value: UnionWithJsonName | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT).members_by_index if self.value is not None: - serializer.write_struct( - _SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT.members["value"], self.value - ) + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -14971,18 +13173,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["value"] = _UnionWithJsonNameDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15003,12 +13205,11 @@ class PostUnionWithJsonNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT.members["value"], self.value - ) + members = hydrate(_SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT).members_by_index + serializer.write_struct(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15017,18 +13218,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["value"] = _UnionWithJsonNameDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "value" not in kwargs: kwargs["value"] = UnionWithJsonNameUnknown(tag="") return kwargs @@ -15037,12 +13238,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: POST_UNION_WITH_JSON_NAME = APIOperation( input=PostUnionWithJsonNameInput, output=PostUnionWithJsonNameOutput, - schema=_SCHEMA_POST_UNION_WITH_JSON_NAME, - input_schema=_SCHEMA_POST_UNION_WITH_JSON_NAME_INPUT, - output_schema=_SCHEMA_POST_UNION_WITH_JSON_NAME_OUTPUT, + static_schema=_SCHEMA_POST_UNION_WITH_JSON_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15055,19 +13253,15 @@ class PutWithContentEncodingInput: data: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT).members_by_index if self.encoding is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"], - self.encoding, - ) + serializer.write_string(members[0], self.encoding) if self.data is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"], self.data - ) + serializer.write_string(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15076,25 +13270,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["encoding"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"] - ) + kwargs["encoding"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"] - ) + kwargs["data"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15113,7 +13303,7 @@ class PutWithContentEncodingOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15125,27 +13315,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_WITH_CONTENT_ENCODING = APIOperation( input=PutWithContentEncodingInput, output=PutWithContentEncodingOutput, - schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, - input_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, - output_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, + static_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15156,14 +13342,16 @@ class QueryIdempotencyTokenAutoFillInput: token: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT + ).members_by_index if self.token is not None: - serializer.write_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"], - self.token, - ) + serializer.write_string(members[0], self.token) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15172,20 +13360,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["token"] = de.read_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"] - ) + kwargs["token"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15204,7 +13390,9 @@ class QueryIdempotencyTokenAutoFillOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15216,27 +13404,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = APIOperation( input=QueryIdempotencyTokenAutoFillInput, output=QueryIdempotencyTokenAutoFillOutput, - schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, - input_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, - output_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + static_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15249,20 +13433,19 @@ class QueryParamsAsStringListMapInput: foo: dict[str, list[str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT + ).members_by_index if self.qux is not None: - serializer.write_string( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["qux"], self.qux - ) + serializer.write_string(members[0], self.qux) if self.foo is not None: - _serialize_string_list_map( - serializer, - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["foo"], - self.foo, - ) + _serialize_string_list_map(serializer, members[1], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15271,25 +13454,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["qux"] = de.read_string( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["qux"] - ) + kwargs["qux"] = de.read_string(members[0]) case 1: - kwargs["foo"] = _deserialize_string_list_map( - de, _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["foo"] - ) + kwargs["foo"] = _deserialize_string_list_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15308,7 +13487,9 @@ class QueryParamsAsStringListMapOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15320,27 +13501,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_PARAMS_AS_STRING_LIST_MAP = APIOperation( input=QueryParamsAsStringListMapInput, output=QueryParamsAsStringListMapOutput, - schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP, - input_schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, - output_schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, + static_schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15353,18 +13530,15 @@ class QueryPrecedenceInput: baz: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PRECEDENCE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_PRECEDENCE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_PRECEDENCE_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_QUERY_PRECEDENCE_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.baz is not None: - _serialize_string_map( - serializer, _SCHEMA_QUERY_PRECEDENCE_INPUT.members["baz"], self.baz - ) + _serialize_string_map(serializer, members[1], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15373,23 +13547,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PRECEDENCE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_QUERY_PRECEDENCE_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["baz"] = _deserialize_string_map( - de, _SCHEMA_QUERY_PRECEDENCE_INPUT.members["baz"] - ) + kwargs["baz"] = _deserialize_string_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_PRECEDENCE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15408,7 +13580,7 @@ class QueryPrecedenceOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PRECEDENCE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_PRECEDENCE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15420,25 +13592,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PRECEDENCE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_PRECEDENCE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_PRECEDENCE = APIOperation( input=QueryPrecedenceInput, output=QueryPrecedenceOutput, - schema=_SCHEMA_QUERY_PRECEDENCE, - input_schema=_SCHEMA_QUERY_PRECEDENCE_INPUT, - output_schema=_SCHEMA_QUERY_PRECEDENCE_OUTPUT, + static_schema=_SCHEMA_QUERY_PRECEDENCE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15447,7 +13617,9 @@ class ResponseCodeHttpFallbackInput: """Dataclass for ResponseCodeHttpFallbackInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15459,15 +13631,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15486,7 +13657,9 @@ class ResponseCodeHttpFallbackOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15498,27 +13671,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RESPONSE_CODE_HTTP_FALLBACK = APIOperation( input=ResponseCodeHttpFallbackInput, output=ResponseCodeHttpFallbackOutput, - schema=_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK, - input_schema=_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_INPUT, - output_schema=_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK_OUTPUT, + static_schema=_SCHEMA_RESPONSE_CODE_HTTP_FALLBACK, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15527,7 +13696,7 @@ class ResponseCodeRequiredInput: """Dataclass for ResponseCodeRequiredInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_CODE_REQUIRED_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_CODE_REQUIRED_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -15539,15 +13708,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RESPONSE_CODE_REQUIRED_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RESPONSE_CODE_REQUIRED_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15568,13 +13736,11 @@ class ResponseCodeRequiredOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT.members["responseCode"], - self.response_code, - ) + members = hydrate(_SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT).members_by_index + serializer.write_integer(members[0], self.response_code) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15583,20 +13749,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["response_code"] = de.read_integer( - _SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT.members["responseCode"] - ) + kwargs["response_code"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) if "response_code" not in kwargs: kwargs["response_code"] = 0 return kwargs @@ -15605,12 +13769,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: RESPONSE_CODE_REQUIRED = APIOperation( input=ResponseCodeRequiredInput, output=ResponseCodeRequiredOutput, - schema=_SCHEMA_RESPONSE_CODE_REQUIRED, - input_schema=_SCHEMA_RESPONSE_CODE_REQUIRED_INPUT, - output_schema=_SCHEMA_RESPONSE_CODE_REQUIRED_OUTPUT, + static_schema=_SCHEMA_RESPONSE_CODE_REQUIRED, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -15639,67 +13800,39 @@ class SimpleScalarPropertiesInput: double_value: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[1], self.string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[9], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15708,69 +13841,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -15809,67 +13918,39 @@ class SimpleScalarPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[1], self.string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[9], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -15878,88 +13959,61 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_PROPERTIES = APIOperation( input=SimpleScalarPropertiesInput, output=SimpleScalarPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_sparse_short_list( serializer: ShapeSerializer, schema: Schema, value: list[int | None] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: if e is None: @@ -15972,7 +14026,7 @@ def _deserialize_sparse_short_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int | None]: result: list[int | None] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -15988,7 +14042,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_sparse_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str | None] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: if e is None: @@ -16001,7 +14055,7 @@ def _deserialize_sparse_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str | None]: result: list[str | None] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -16023,22 +14077,17 @@ class SparseJsonListsInput: sparse_short_list: list[int | None] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_JSON_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_JSON_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_JSON_LISTS_INPUT).members_by_index if self.sparse_string_list is not None: _serialize_sparse_string_list( - serializer, - _SCHEMA_SPARSE_JSON_LISTS_INPUT.members["sparseStringList"], - self.sparse_string_list, + serializer, members[0], self.sparse_string_list ) if self.sparse_short_list is not None: - _serialize_sparse_short_list( - serializer, - _SCHEMA_SPARSE_JSON_LISTS_INPUT.members["sparseShortList"], - self.sparse_short_list, - ) + _serialize_sparse_short_list(serializer, members[1], self.sparse_short_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16047,23 +14096,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_JSON_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_string_list"] = _deserialize_sparse_string_list( - de, _SCHEMA_SPARSE_JSON_LISTS_INPUT.members["sparseStringList"] + de, members[0] ) case 1: kwargs["sparse_short_list"] = _deserialize_sparse_short_list( - de, _SCHEMA_SPARSE_JSON_LISTS_INPUT.members["sparseShortList"] + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SPARSE_JSON_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16086,22 +14137,17 @@ class SparseJsonListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_JSON_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_JSON_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_JSON_LISTS_OUTPUT).members_by_index if self.sparse_string_list is not None: _serialize_sparse_string_list( - serializer, - _SCHEMA_SPARSE_JSON_LISTS_OUTPUT.members["sparseStringList"], - self.sparse_string_list, + serializer, members[0], self.sparse_string_list ) if self.sparse_short_list is not None: - _serialize_sparse_short_list( - serializer, - _SCHEMA_SPARSE_JSON_LISTS_OUTPUT.members["sparseShortList"], - self.sparse_short_list, - ) + _serialize_sparse_short_list(serializer, members[1], self.sparse_short_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16110,35 +14156,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_JSON_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_string_list"] = _deserialize_sparse_string_list( - de, _SCHEMA_SPARSE_JSON_LISTS_OUTPUT.members["sparseStringList"] + de, members[0] ) case 1: kwargs["sparse_short_list"] = _deserialize_sparse_short_list( - de, _SCHEMA_SPARSE_JSON_LISTS_OUTPUT.members["sparseShortList"] + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SPARSE_JSON_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SPARSE_JSON_LISTS = APIOperation( input=SparseJsonListsInput, output=SparseJsonListsOutput, - schema=_SCHEMA_SPARSE_JSON_LISTS, - input_schema=_SCHEMA_SPARSE_JSON_LISTS_INPUT, - output_schema=_SCHEMA_SPARSE_JSON_LISTS_OUTPUT, + static_schema=_SCHEMA_SPARSE_JSON_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -16146,7 +14191,7 @@ def _serialize_sparse_boolean_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, bool | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -16158,7 +14203,7 @@ def _deserialize_sparse_boolean_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, bool | None]: result: dict[str, bool | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -16175,7 +14220,7 @@ def _serialize_sparse_number_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -16187,7 +14232,7 @@ def _deserialize_sparse_number_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int | None]: result: dict[str, int | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -16204,7 +14249,7 @@ def _serialize_sparse_set_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str] | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -16216,7 +14261,7 @@ def _deserialize_sparse_set_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str] | None]: result: dict[str, list[str] | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -16233,7 +14278,7 @@ def _serialize_sparse_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -16245,7 +14290,7 @@ def _deserialize_sparse_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str | None]: result: dict[str, str | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -16262,7 +14307,7 @@ def _serialize_sparse_struct_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -16274,7 +14319,7 @@ def _deserialize_sparse_struct_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct | None]: result: dict[str, GreetingStruct | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -16302,43 +14347,26 @@ class SparseJsonMapsInput: sparse_set_map: dict[str, list[str] | None] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_JSON_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_JSON_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_JSON_MAPS_INPUT).members_by_index if self.sparse_struct_map is not None: - _serialize_sparse_struct_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseStructMap"], - self.sparse_struct_map, - ) + _serialize_sparse_struct_map(serializer, members[0], self.sparse_struct_map) if self.sparse_number_map is not None: - _serialize_sparse_number_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseNumberMap"], - self.sparse_number_map, - ) + _serialize_sparse_number_map(serializer, members[1], self.sparse_number_map) if self.sparse_boolean_map is not None: _serialize_sparse_boolean_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseBooleanMap"], - self.sparse_boolean_map, + serializer, members[2], self.sparse_boolean_map ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[3], self.sparse_string_map) if self.sparse_set_map is not None: - _serialize_sparse_set_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseSetMap"], - self.sparse_set_map, - ) + _serialize_sparse_set_map(serializer, members[4], self.sparse_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16347,38 +14375,40 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_JSON_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_struct_map"] = _deserialize_sparse_struct_map( - de, _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseStructMap"] + de, members[0] ) case 1: kwargs["sparse_number_map"] = _deserialize_sparse_number_map( - de, _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseNumberMap"] + de, members[1] ) case 2: kwargs["sparse_boolean_map"] = _deserialize_sparse_boolean_map( - de, _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseBooleanMap"] + de, members[2] ) case 3: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseStringMap"] + de, members[3] ) case 4: kwargs["sparse_set_map"] = _deserialize_sparse_set_map( - de, _SCHEMA_SPARSE_JSON_MAPS_INPUT.members["sparseSetMap"] + de, members[4] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SPARSE_JSON_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16407,43 +14437,26 @@ class SparseJsonMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_JSON_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_JSON_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_JSON_MAPS_OUTPUT).members_by_index if self.sparse_struct_map is not None: - _serialize_sparse_struct_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseStructMap"], - self.sparse_struct_map, - ) + _serialize_sparse_struct_map(serializer, members[0], self.sparse_struct_map) if self.sparse_number_map is not None: - _serialize_sparse_number_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseNumberMap"], - self.sparse_number_map, - ) + _serialize_sparse_number_map(serializer, members[1], self.sparse_number_map) if self.sparse_boolean_map is not None: _serialize_sparse_boolean_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseBooleanMap"], - self.sparse_boolean_map, + serializer, members[2], self.sparse_boolean_map ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[3], self.sparse_string_map) if self.sparse_set_map is not None: - _serialize_sparse_set_map( - serializer, - _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseSetMap"], - self.sparse_set_map, - ) + _serialize_sparse_set_map(serializer, members[4], self.sparse_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16452,50 +14465,49 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_JSON_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_struct_map"] = _deserialize_sparse_struct_map( - de, _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseStructMap"] + de, members[0] ) case 1: kwargs["sparse_number_map"] = _deserialize_sparse_number_map( - de, _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseNumberMap"] + de, members[1] ) case 2: kwargs["sparse_boolean_map"] = _deserialize_sparse_boolean_map( - de, _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseBooleanMap"] + de, members[2] ) case 3: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseStringMap"] + de, members[3] ) case 4: kwargs["sparse_set_map"] = _deserialize_sparse_set_map( - de, _SCHEMA_SPARSE_JSON_MAPS_OUTPUT.members["sparseSetMap"] + de, members[4] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_SPARSE_JSON_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SPARSE_JSON_MAPS = APIOperation( input=SparseJsonMapsInput, output=SparseJsonMapsOutput, - schema=_SCHEMA_SPARSE_JSON_MAPS, - input_schema=_SCHEMA_SPARSE_JSON_MAPS_INPUT, - output_schema=_SCHEMA_SPARSE_JSON_MAPS_OUTPUT, + static_schema=_SCHEMA_SPARSE_JSON_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -16508,18 +14520,15 @@ class StreamingTraitsInput: blob: StreamingBlob = b64decode("") def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STREAMING_TRAITS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_STREAMING_TRAITS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STREAMING_TRAITS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_STREAMING_TRAITS_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_data_stream( - _SCHEMA_STREAMING_TRAITS_INPUT.members["blob"], self.blob - ) + serializer.write_data_stream(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16528,23 +14537,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STREAMING_TRAITS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_STREAMING_TRAITS_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_data_stream( - _SCHEMA_STREAMING_TRAITS_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_data_stream(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STREAMING_TRAITS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16567,17 +14574,14 @@ class StreamingTraitsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STREAMING_TRAITS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_STREAMING_TRAITS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STREAMING_TRAITS_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_STREAMING_TRAITS_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) - serializer.write_data_stream( - _SCHEMA_STREAMING_TRAITS_OUTPUT.members["blob"], self.blob - ) + serializer.write_data_stream(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16586,35 +14590,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STREAMING_TRAITS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_STREAMING_TRAITS_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_data_stream( - _SCHEMA_STREAMING_TRAITS_OUTPUT.members["blob"] - ) + kwargs["blob"] = de.read_data_stream(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STREAMING_TRAITS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs STREAMING_TRAITS = APIOperation( input=StreamingTraitsInput, output=StreamingTraitsOutput, - schema=_SCHEMA_STREAMING_TRAITS, - input_schema=_SCHEMA_STREAMING_TRAITS_INPUT, - output_schema=_SCHEMA_STREAMING_TRAITS_OUTPUT, + static_schema=_SCHEMA_STREAMING_TRAITS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -16627,18 +14626,19 @@ class StreamingTraitsRequireLengthInput: blob: StreamingBlob = b64decode("") def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_data_stream( - _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT.members["blob"], self.blob - ) + serializer.write_data_stream(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16647,25 +14647,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_data_stream( - _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_data_stream(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16684,7 +14680,9 @@ class StreamingTraitsRequireLengthOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -16696,27 +14694,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs STREAMING_TRAITS_REQUIRE_LENGTH = APIOperation( input=StreamingTraitsRequireLengthInput, output=StreamingTraitsRequireLengthOutput, - schema=_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH, - input_schema=_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_INPUT, - output_schema=_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT, + static_schema=_SCHEMA_STREAMING_TRAITS_REQUIRE_LENGTH, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -16729,19 +14723,19 @@ class StreamingTraitsWithMediaTypeInput: blob: StreamingBlob = b64decode("") def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_data_stream( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT.members["blob"], - self.blob, - ) + serializer.write_data_stream(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16750,25 +14744,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_data_stream( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_data_stream(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16791,17 +14781,18 @@ class StreamingTraitsWithMediaTypeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) - serializer.write_data_stream( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["blob"], self.blob - ) + serializer.write_data_stream(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16810,37 +14801,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_data_stream( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["blob"] - ) + kwargs["blob"] = de.read_data_stream(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs STREAMING_TRAITS_WITH_MEDIA_TYPE = APIOperation( input=StreamingTraitsWithMediaTypeInput, output=StreamingTraitsWithMediaTypeOutput, - schema=_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE, - input_schema=_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT, - output_schema=_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + static_schema=_SCHEMA_STREAMING_TRAITS_WITH_MEDIA_TYPE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -16851,13 +14835,12 @@ class TestConfig: timeout: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_CONFIG, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_CONFIG), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_CONFIG).members_by_index if self.timeout is not None: - serializer.write_integer( - _SCHEMA_TEST_CONFIG.members["timeout"], self.timeout - ) + serializer.write_integer(members[0], self.timeout) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16866,18 +14849,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_CONFIG) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["timeout"] = de.read_integer( - _SCHEMA_TEST_CONFIG.members["timeout"] - ) + kwargs["timeout"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_CONFIG, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16890,19 +14873,15 @@ class TestBodyStructureInput: test_config: TestConfig | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_BODY_STRUCTURE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_BODY_STRUCTURE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_BODY_STRUCTURE_INPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_BODY_STRUCTURE_INPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) if self.test_config is not None: - serializer.write_struct( - _SCHEMA_TEST_BODY_STRUCTURE_INPUT.members["testConfig"], - self.test_config, - ) + serializer.write_struct(members[1], self.test_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16911,21 +14890,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_BODY_STRUCTURE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_BODY_STRUCTURE_INPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case 1: kwargs["test_config"] = TestConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_BODY_STRUCTURE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -16948,19 +14927,15 @@ class TestBodyStructureOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_BODY_STRUCTURE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_BODY_STRUCTURE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_BODY_STRUCTURE_OUTPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_BODY_STRUCTURE_OUTPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) if self.test_config is not None: - serializer.write_struct( - _SCHEMA_TEST_BODY_STRUCTURE_OUTPUT.members["testConfig"], - self.test_config, - ) + serializer.write_struct(members[1], self.test_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -16969,33 +14944,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_BODY_STRUCTURE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_BODY_STRUCTURE_OUTPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case 1: kwargs["test_config"] = TestConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_BODY_STRUCTURE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_BODY_STRUCTURE = APIOperation( input=TestBodyStructureInput, output=TestBodyStructureOutput, - schema=_SCHEMA_TEST_BODY_STRUCTURE, - input_schema=_SCHEMA_TEST_BODY_STRUCTURE_INPUT, - output_schema=_SCHEMA_TEST_BODY_STRUCTURE_OUTPUT, + static_schema=_SCHEMA_TEST_BODY_STRUCTURE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17004,7 +14976,9 @@ class TestGetNoInputNoPayloadInput: """Dataclass for TestGetNoInputNoPayloadInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -17016,15 +14990,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17045,14 +15018,14 @@ class TestGetNoInputNoPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT.members["testId"], - self.test_id, - ) + serializer.write_string(members[0], self.test_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17061,32 +15034,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_GET_NO_INPUT_NO_PAYLOAD = APIOperation( input=TestGetNoInputNoPayloadInput, output=TestGetNoInputNoPayloadOutput, - schema=_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD, - input_schema=_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT, - output_schema=_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_TEST_GET_NO_INPUT_NO_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17097,13 +15065,12 @@ class TestGetNoPayloadInput: test_id: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_GET_NO_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_GET_NO_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_GET_NO_PAYLOAD_INPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_GET_NO_PAYLOAD_INPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17112,18 +15079,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_GET_NO_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_GET_NO_PAYLOAD_INPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_GET_NO_PAYLOAD_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17144,13 +15111,12 @@ class TestGetNoPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17159,30 +15125,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_GET_NO_PAYLOAD = APIOperation( input=TestGetNoPayloadInput, output=TestGetNoPayloadOutput, - schema=_SCHEMA_TEST_GET_NO_PAYLOAD, - input_schema=_SCHEMA_TEST_GET_NO_PAYLOAD_INPUT, - output_schema=_SCHEMA_TEST_GET_NO_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_TEST_GET_NO_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17195,19 +15158,15 @@ class TestPayloadBlobInput: data: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_PAYLOAD_BLOB_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_PAYLOAD_BLOB_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_PAYLOAD_BLOB_INPUT).members_by_index if self.content_type is not None: - serializer.write_string( - _SCHEMA_TEST_PAYLOAD_BLOB_INPUT.members["contentType"], - self.content_type, - ) + serializer.write_string(members[0], self.content_type) if self.data is not None: - serializer.write_blob( - _SCHEMA_TEST_PAYLOAD_BLOB_INPUT.members["data"], self.data - ) + serializer.write_blob(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17216,23 +15175,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_PAYLOAD_BLOB_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["content_type"] = de.read_string( - _SCHEMA_TEST_PAYLOAD_BLOB_INPUT.members["contentType"] - ) + kwargs["content_type"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_blob( - _SCHEMA_TEST_PAYLOAD_BLOB_INPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_PAYLOAD_BLOB_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17255,19 +15212,15 @@ class TestPayloadBlobOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT).members_by_index if self.content_type is not None: - serializer.write_string( - _SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT.members["contentType"], - self.content_type, - ) + serializer.write_string(members[0], self.content_type) if self.data is not None: - serializer.write_blob( - _SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT.members["data"], self.data - ) + serializer.write_blob(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17276,35 +15229,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["content_type"] = de.read_string( - _SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT.members["contentType"] - ) + kwargs["content_type"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_blob( - _SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_PAYLOAD_BLOB = APIOperation( input=TestPayloadBlobInput, output=TestPayloadBlobOutput, - schema=_SCHEMA_TEST_PAYLOAD_BLOB, - input_schema=_SCHEMA_TEST_PAYLOAD_BLOB_INPUT, - output_schema=_SCHEMA_TEST_PAYLOAD_BLOB_OUTPUT, + static_schema=_SCHEMA_TEST_PAYLOAD_BLOB, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17317,19 +15265,15 @@ class TestPayloadStructureInput: payload_config: PayloadConfig | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) if self.payload_config is not None: - serializer.write_struct( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT.members["payloadConfig"], - self.payload_config, - ) + serializer.write_struct(members[1], self.payload_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17338,23 +15282,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case 1: kwargs["payload_config"] = PayloadConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17377,19 +15319,15 @@ class TestPayloadStructureOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) if self.payload_config is not None: - serializer.write_struct( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT.members["payloadConfig"], - self.payload_config, - ) + serializer.write_struct(members[1], self.payload_config) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17398,35 +15336,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case 1: kwargs["payload_config"] = PayloadConfig.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_PAYLOAD_STRUCTURE = APIOperation( input=TestPayloadStructureInput, output=TestPayloadStructureOutput, - schema=_SCHEMA_TEST_PAYLOAD_STRUCTURE, - input_schema=_SCHEMA_TEST_PAYLOAD_STRUCTURE_INPUT, - output_schema=_SCHEMA_TEST_PAYLOAD_STRUCTURE_OUTPUT, + static_schema=_SCHEMA_TEST_PAYLOAD_STRUCTURE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17435,7 +15368,9 @@ class TestPostNoInputNoPayloadInput: """Dataclass for TestPostNoInputNoPayloadInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -17447,15 +15382,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17476,14 +15410,14 @@ class TestPostNoInputNoPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT.members["testId"], - self.test_id, - ) + serializer.write_string(members[0], self.test_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17492,32 +15426,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_POST_NO_INPUT_NO_PAYLOAD = APIOperation( input=TestPostNoInputNoPayloadInput, output=TestPostNoInputNoPayloadOutput, - schema=_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD, - input_schema=_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT, - output_schema=_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_TEST_POST_NO_INPUT_NO_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17528,13 +15457,12 @@ class TestPostNoPayloadInput: test_id: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_POST_NO_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_POST_NO_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_POST_NO_PAYLOAD_INPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_POST_NO_PAYLOAD_INPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17543,18 +15471,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_POST_NO_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_POST_NO_PAYLOAD_INPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_TEST_POST_NO_PAYLOAD_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17575,13 +15503,12 @@ class TestPostNoPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT).members_by_index if self.test_id is not None: - serializer.write_string( - _SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT.members["testId"], self.test_id - ) + serializer.write_string(members[0], self.test_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17590,32 +15517,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["test_id"] = de.read_string( - _SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT.members["testId"] - ) + kwargs["test_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TEST_POST_NO_PAYLOAD = APIOperation( input=TestPostNoPayloadInput, output=TestPostNoPayloadOutput, - schema=_SCHEMA_TEST_POST_NO_PAYLOAD, - input_schema=_SCHEMA_TEST_POST_NO_PAYLOAD_INPUT, - output_schema=_SCHEMA_TEST_POST_NO_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_TEST_POST_NO_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17638,50 +15560,30 @@ class TimestampFormatHeadersInput: target_date_time: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT).members_by_index if self.member_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberEpochSeconds"], - self.member_epoch_seconds, - ) + serializer.write_timestamp(members[0], self.member_epoch_seconds) if self.member_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberHttpDate"], - self.member_http_date, - ) + serializer.write_timestamp(members[1], self.member_http_date) if self.member_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberDateTime"], - self.member_date_time, - ) + serializer.write_timestamp(members[2], self.member_date_time) if self.default_format is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["defaultFormat"], - self.default_format, - ) + serializer.write_timestamp(members[3], self.default_format) if self.target_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetEpochSeconds"], - self.target_epoch_seconds, - ) + serializer.write_timestamp(members[4], self.target_epoch_seconds) if self.target_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetHttpDate"], - self.target_http_date, - ) + serializer.write_timestamp(members[5], self.target_http_date) if self.target_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetDateTime"], - self.target_date_time, - ) + serializer.write_timestamp(members[6], self.target_date_time) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17690,54 +15592,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members[ - "memberEpochSeconds" - ] - ) + kwargs["member_epoch_seconds"] = de.read_timestamp(members[0]) case 1: - kwargs["member_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberHttpDate"] - ) + kwargs["member_http_date"] = de.read_timestamp(members[1]) case 2: - kwargs["member_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberDateTime"] - ) + kwargs["member_date_time"] = de.read_timestamp(members[2]) case 3: - kwargs["default_format"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["defaultFormat"] - ) + kwargs["default_format"] = de.read_timestamp(members[3]) case 4: - kwargs["target_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members[ - "targetEpochSeconds" - ] - ) + kwargs["target_epoch_seconds"] = de.read_timestamp(members[4]) case 5: - kwargs["target_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetHttpDate"] - ) + kwargs["target_http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["target_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetDateTime"] - ) + kwargs["target_date_time"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17770,50 +15654,30 @@ class TimestampFormatHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT).members_by_index if self.member_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["memberEpochSeconds"], - self.member_epoch_seconds, - ) + serializer.write_timestamp(members[0], self.member_epoch_seconds) if self.member_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["memberHttpDate"], - self.member_http_date, - ) + serializer.write_timestamp(members[1], self.member_http_date) if self.member_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["memberDateTime"], - self.member_date_time, - ) + serializer.write_timestamp(members[2], self.member_date_time) if self.default_format is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["defaultFormat"], - self.default_format, - ) + serializer.write_timestamp(members[3], self.default_format) if self.target_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["targetEpochSeconds"], - self.target_epoch_seconds, - ) + serializer.write_timestamp(members[4], self.target_epoch_seconds) if self.target_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["targetHttpDate"], - self.target_http_date, - ) + serializer.write_timestamp(members[5], self.target_http_date) if self.target_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["targetDateTime"], - self.target_date_time, - ) + serializer.write_timestamp(members[6], self.target_date_time) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -17822,74 +15686,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "memberEpochSeconds" - ] - ) + kwargs["member_epoch_seconds"] = de.read_timestamp(members[0]) case 1: - kwargs["member_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "memberHttpDate" - ] - ) + kwargs["member_http_date"] = de.read_timestamp(members[1]) case 2: - kwargs["member_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "memberDateTime" - ] - ) + kwargs["member_date_time"] = de.read_timestamp(members[2]) case 3: - kwargs["default_format"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["defaultFormat"] - ) + kwargs["default_format"] = de.read_timestamp(members[3]) case 4: - kwargs["target_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "targetEpochSeconds" - ] - ) + kwargs["target_epoch_seconds"] = de.read_timestamp(members[4]) case 5: - kwargs["target_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "targetHttpDate" - ] - ) + kwargs["target_http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["target_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "targetDateTime" - ] - ) + kwargs["target_date_time"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TIMESTAMP_FORMAT_HEADERS = APIOperation( input=TimestampFormatHeadersInput, output=TimestampFormatHeadersOutput, - schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS, - input_schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT, - output_schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT, + static_schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17898,7 +15733,7 @@ class UnitInputAndOutputInput: """Dataclass for UnitInputAndOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNIT_INPUT_AND_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_UNIT_INPUT_AND_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -17910,15 +15745,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_UNIT_INPUT_AND_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_UNIT_INPUT_AND_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -17937,7 +15771,7 @@ class UnitInputAndOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNIT_INPUT_AND_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_UNIT_INPUT_AND_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -17949,27 +15783,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_UNIT_INPUT_AND_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_UNIT_INPUT_AND_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs UNIT_INPUT_AND_OUTPUT = APIOperation( input=UnitInputAndOutputInput, output=UnitInputAndOutputOutput, - schema=_SCHEMA_UNIT_INPUT_AND_OUTPUT, - input_schema=_SCHEMA_UNIT_INPUT_AND_OUTPUT_INPUT, - output_schema=_SCHEMA_UNIT_INPUT_AND_OUTPUT_OUTPUT, + static_schema=_SCHEMA_UNIT_INPUT_AND_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -17982,19 +15812,19 @@ class RecursiveShapesInputOutputNested1: nested: "RecursiveShapesInputOutputNested2 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["nested"], - self.nested, - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18003,23 +15833,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: kwargs["nested"] = RecursiveShapesInputOutputNested2.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -18032,21 +15860,19 @@ class RecursiveShapesInputOutputNested2: recursive_member: "RecursiveShapesInputOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 + ).members_by_index if self.bar is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members["bar"], self.bar - ) + serializer.write_string(members[0], self.bar) if self.recursive_member is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members[ - "recursiveMember" - ], - self.recursive_member, - ) + serializer.write_struct(members[1], self.recursive_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18055,13 +15881,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bar"] = de.read_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members["bar"] - ) + kwargs["bar"] = de.read_string(members[0]) case 1: kwargs["recursive_member"] = ( @@ -18069,11 +15895,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -18084,13 +15908,12 @@ class RecursiveShapesInput: nested: "RecursiveShapesInputOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18099,16 +15922,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveShapesInputOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -18129,13 +15954,12 @@ class RecursiveShapesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -18144,26 +15968,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveShapesInputOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_SHAPES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RECURSIVE_SHAPES = APIOperation( input=RecursiveShapesInput, output=RecursiveShapesOutput, - schema=_SCHEMA_RECURSIVE_SHAPES, - input_schema=_SCHEMA_RECURSIVE_SHAPES_INPUT, - output_schema=_SCHEMA_RECURSIVE_SHAPES_OUTPUT, + static_schema=_SCHEMA_RECURSIVE_SHAPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) diff --git a/codegen-output/rest-xml-with-namespace/pyproject.toml b/codegen-output/rest-xml-with-namespace/pyproject.toml index abe4a6800..a33d1c326 100644 --- a/codegen-output/rest-xml-with-namespace/pyproject.toml +++ b/codegen-output/rest-xml-with-namespace/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py b/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py index ef8868919..340c4ff98 100644 --- a/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py +++ b/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py @@ -2,407 +2,364 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BOOLEAN, - BYTE, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait +n0 = "aws.protocoltests.restxml.xmlns" +_NWN = "NestedWithNamespace" +_aF = "attrField" +_sN = "smithy.api#xmlName" +_xN = "xsi:someName" +_sA = "smithy.api#xmlAttribute" +_SSPI = "SimpleScalarPropertiesInput" +_sSI = "smithy.synthetic#originalShapeId" +_aSSPR = "aws.protocoltests.restxml.xmlns#SimpleScalarPropertiesRequest" +_f = "foo" +_sH = "smithy.api#httpHeader" +_XF = "X-Foo" +_sV = "stringValue" +_tBV = "trueBooleanValue" +_fBV = "falseBooleanValue" +_bV = "byteValue" +_sVh = "shortValue" +_iV = "integerValue" +_lV = "longValue" +_fV = "floatValue" +_N = "Nested" +_sNm = "smithy.api#xmlNamespace" +_dV = "doubleValue" +_DD = "DoubleDribble" +_SSPO = "SimpleScalarPropertiesOutput" +_aSSPRw = "aws.protocoltests.restxml.xmlns#SimpleScalarPropertiesResponse" +_SSP = "SimpleScalarProperties" +_s = "smithy.api#http" +_RXWN = "RestXmlWithNamespace" +_a = "aws.auth#sigv4" +_aX = "aws.protocols#restXml" +_sB = "smithy.rules#endpointBdd" +_aw = "aws.api#service" -NESTED_WITH_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml.xmlns#NestedWithNamespace"), - members={ - "attrField": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="xsi:someName"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - } - }, -) +NESTED_WITH_NAMESPACE = (18, n0, _NWN, 0, (_aF,), ((3, {_sN: _xN, _sA: None}),)) -SIMPLE_SCALAR_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml.xmlns#SimpleScalarPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml.xmlns#SimpleScalarPropertiesRequest", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "stringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "Nested": { - "target": NESTED_WITH_NAMESPACE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType( - {"prefix": "xsi", "uri": "https://example.com"} - ), - ) - ], - }, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="DoubleDribble") - ], - }, - }, +SIMPLE_SCALAR_PROPERTIES_INPUT = ( + 18, + n0, + _SSPI, + {_sSI: _aSSPR}, + (_f, _sV, _tBV, _fBV, _bV, _sVh, _iV, _lV, _fV, _N, _dV), + ( + (3, {_sH: _XF}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + ( + NESTED_WITH_NAMESPACE, + {_sNm: MappingProxyType({"prefix": "xsi", "uri": "https://example.com"})}, + ), + (10, {_sN: _DD}), + ), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml.xmlns#SimpleScalarPropertiesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml.xmlns#SimpleScalarPropertiesResponse", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "stringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "Nested": { - "target": NESTED_WITH_NAMESPACE, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType( - {"prefix": "xsi", "uri": "https://example.com"} - ), - ) - ], - }, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="DoubleDribble") - ], - }, - }, +SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( + 18, + n0, + _SSPO, + {_sSI: _aSSPRw}, + (_f, _sV, _tBV, _fBV, _bV, _sVh, _iV, _lV, _fV, _N, _dV), + ( + (3, {_sH: _XF}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + ( + NESTED_WITH_NAMESPACE, + {_sNm: MappingProxyType({"prefix": "xsi", "uri": "https://example.com"})}, + ), + (10, {_sN: _DD}), + ), ) -SIMPLE_SCALAR_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.restxml.xmlns#SimpleScalarProperties"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"}), - ) - ], +SIMPLE_SCALAR_PROPERTIES = ( + 23, + n0, + _SSP, + {_s: MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"})}, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), ) -REST_XML_WITH_NAMESPACE = Schema( - id=ShapeID("aws.protocoltests.restxml.xmlns#RestXmlWithNamespace"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), - value=MappingProxyType({"name": "restxmlwithnamespace"}), - ), - Trait.new(id=ShapeID("aws.protocols#restXml")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), - } - ), - MappingProxyType( +REST_XML_WITH_NAMESPACE = ( + 21, + n0, + _RXWN, + { + _a: MappingProxyType({"name": "restxmlwithnamespace"}), + _aX: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), - } - ), - MappingProxyType( - { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://restxmlwithnamespace-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://restxmlwithnamespace.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://restxmlwithnamespace-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://restxmlwithnamespace.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://restxmlwithnamespace.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), - ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType({"sdkId": "Rest Xml Protocol Namespace"}), - ), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://example.com"}), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxmlwithnamespace-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxmlwithnamespace.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxmlwithnamespace-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxmlwithnamespace.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxmlwithnamespace.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - ], + _aw: MappingProxyType({"sdkId": "Rest Xml Protocol Namespace"}), + _sNm: MappingProxyType({"uri": "https://example.com"}), + }, ) diff --git a/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/models.py b/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/models.py index 68de52fdc..8973d446d 100644 --- a/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/models.py +++ b/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/models.py @@ -4,6 +4,7 @@ import logging from typing import Any, Self +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import TypeRegistry from smithy_core.exceptions import ModeledError @@ -39,13 +40,12 @@ class NestedWithNamespace: attr_field: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_WITH_NAMESPACE, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_WITH_NAMESPACE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_WITH_NAMESPACE).members_by_index if self.attr_field is not None: - serializer.write_string( - _SCHEMA_NESTED_WITH_NAMESPACE.members["attrField"], self.attr_field - ) + serializer.write_string(members[0], self.attr_field) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -54,18 +54,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_WITH_NAMESPACE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["attr_field"] = de.read_string( - _SCHEMA_NESTED_WITH_NAMESPACE.members["attrField"] - ) + kwargs["attr_field"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_WITH_NAMESPACE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -96,72 +96,42 @@ class SimpleScalarPropertiesInput: double_value: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[1], self.string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.nested is not None: - serializer.write_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["Nested"], self.nested - ) + serializer.write_struct(members[9], self.nested) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[10], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -170,72 +140,48 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: kwargs["nested"] = NestedWithNamespace.deserialize(de) case 10: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[10]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -276,72 +222,42 @@ class SimpleScalarPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[1], self.string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.nested is not None: - serializer.write_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["Nested"], self.nested - ) + serializer.write_struct(members[9], self.nested) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[10], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -350,82 +266,55 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: kwargs["nested"] = NestedWithNamespace.deserialize(de) case 10: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[10]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_PROPERTIES = APIOperation( input=SimpleScalarPropertiesInput, output=SimpleScalarPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) diff --git a/codegen-output/rest-xml/pyproject.toml b/codegen-output/rest-xml/pyproject.toml index e59812bfa..603803fde 100644 --- a/codegen-output/rest-xml/pyproject.toml +++ b/codegen-output/rest-xml/pyproject.toml @@ -52,6 +52,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rest-xml/src/restxml/_private/schemas.py b/codegen-output/rest-xml/src/restxml/_private/schemas.py index f448b463a..ac54da14f 100644 --- a/codegen-output/rest-xml/src/restxml/_private/schemas.py +++ b/codegen-output/rest-xml/src/restxml/_private/schemas.py @@ -2,4160 +2,3035 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - BYTE, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -BOOLEAN_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#BooleanList"), - shape_type=ShapeType.LIST, - members={"member": {"target": BOOLEAN}}, -) - -DOUBLE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#DoubleList"), - shape_type=ShapeType.LIST, - members={"member": {"target": DOUBLE}}, -) - -FOO_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, -) - -FOO_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) - -INTEGER_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, -) - -INTEGER_ENUM_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) - -INTEGER_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) - -INTEGER_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) - -STRING_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -STRING_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -TIMESTAMP_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#TimestampList"), - shape_type=ShapeType.LIST, - members={"member": {"target": TIMESTAMP}}, -) - -ALL_QUERY_STRING_TYPES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#AllQueryStringTypesInput"), - members={ - "queryString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="String")], - }, - "queryStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="StringList") - ], - }, - "queryStringSet": { - "target": STRING_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="StringSet") - ], - }, - "queryByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Byte")], - }, - "queryShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Short")], - }, - "queryInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Integer")], - }, - "queryIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerList") - ], - }, - "queryIntegerSet": { - "target": INTEGER_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerSet") - ], - }, - "queryLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Long")], - }, - "queryFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Float")], - }, - "queryDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Double")], - }, - "queryDoubleList": { - "target": DOUBLE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="DoubleList") - ], - }, - "queryBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Boolean")], - }, - "queryBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="BooleanList") - ], - }, - "queryTimestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Timestamp") - ], - }, - "queryTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="TimestampList") - ], - }, - "queryEnum": { - "target": FOO_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Enum")], - }, - "queryEnumList": { - "target": FOO_ENUM_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="EnumList")], - }, - "queryIntegerEnum": { - "target": INTEGER_ENUM, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerEnum") - ], - }, - "queryIntegerEnumList": { - "target": INTEGER_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="IntegerEnumList") - ], - }, - "queryParamsMapOfStrings": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - }, - }, -) - -ALL_QUERY_STRING_TYPES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#AllQueryStringTypesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ALL_QUERY_STRING_TYPES = Schema( - id=ShapeID("aws.protocoltests.restxml#AllQueryStringTypes"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/AllQueryStringTypesInput", "method": "GET"} - ), - ) - ], -) - -PAYLOAD_WITH_XML_NAME = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#PayloadWithXmlName"), - traits=[Trait.new(id=ShapeID("smithy.api#xmlName"), value="Hello")], - members={"name": {"target": STRING}}, -) - -BODY_WITH_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#BodyWithXmlNameInput"), - traits=[ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="Ahoy"), - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#BodyWithXmlNameInputOutput", - ), - ], - members={"nested": {"target": PAYLOAD_WITH_XML_NAME}}, -) - -BODY_WITH_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#BodyWithXmlNameOutput"), - traits=[ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="Ahoy"), - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#BodyWithXmlNameInputOutput", - ), - ], - members={"nested": {"target": PAYLOAD_WITH_XML_NAME}}, -) - -BODY_WITH_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.restxml#BodyWithXmlName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/BodyWithXmlName", "method": "PUT"}), - ) - ], -) - -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ComplexNestedErrorData"), - members={"Foo": {"target": STRING}}, -) - -COMPLEX_ERROR = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ComplexError"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=403), - ], - members={ - "Header": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Header") - ], - }, - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, -) - -CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ConstantAndVariableQueryStringInput"), - members={ - "baz": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="baz")], - }, - "maybeSet": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="maybeSet")], - }, - }, -) - -CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ConstantAndVariableQueryStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -CONSTANT_AND_VARIABLE_QUERY_STRING = Schema( - id=ShapeID("aws.protocoltests.restxml#ConstantAndVariableQueryString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/ConstantAndVariableQueryString?foo=bar", "method": "GET"} - ), - ) - ], -) - -CONSTANT_QUERY_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ConstantQueryStringInput"), - members={ - "hello": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - } - }, -) - -CONSTANT_QUERY_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ConstantQueryStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -CONSTANT_QUERY_STRING = Schema( - id=ShapeID("aws.protocoltests.restxml#ConstantQueryString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/ConstantQueryString/{hello}?foo=bar&hello", "method": "GET"} - ), - ) - ], -) - -CONTENT_TYPE_PARAMETERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ContentTypeParametersInput"), - members={"value": {"target": INTEGER}}, -) - -CONTENT_TYPE_PARAMETERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ContentTypeParametersOutput") -) - -CONTENT_TYPE_PARAMETERS = Schema( - id=ShapeID("aws.protocoltests.restxml#ContentTypeParameters"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/ContentTypeParameters", "method": "PUT"}), - ) - ], -) - -DATETIME_OFFSETS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#DatetimeOffsetsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -DATE_TIME = Schema( - id=ShapeID("aws.protocoltests.shared#DateTime"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], -) - -DATETIME_OFFSETS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#DatetimeOffsetsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -DATETIME_OFFSETS = Schema( - id=ShapeID("aws.protocoltests.restxml#DatetimeOffsets"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/DatetimeOffsets", "method": "POST"}), - ) - ], -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EmptyInputAndEmptyOutputInput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EmptyInputAndEmptyOutputOutput") -) - -EMPTY_INPUT_AND_EMPTY_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restxml#EmptyInputAndEmptyOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/EmptyInputAndEmptyOutput", "method": "POST"} - ), - ) - ], -) - -ENDPOINT_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EndpointOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) -ENDPOINT_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EndpointOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -ENDPOINT_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restxml#EndpointOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo."}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/EndpointOperation", "method": "POST"}), - ), - ], +n0 = "aws.protocoltests.shared" +_BL = "BooleanList" +_m = "member" +_DL = "DoubleList" +_FE = "FooEnum" +_FOO = "FOO" +_BAZ = "BAZ" +_BAR = "BAR" +_ONE = "ONE" +_ZERO = "ZERO" +_FEL = "FooEnumList" +_IE = "IntegerEnum" +_A = "A" +_B = "B" +_C = "C" +_IEL = "IntegerEnumList" +_IL = "IntegerList" +_IS = "IntegerSet" +_SM = "StringMap" +_k = "key" +_v = "value" +_SL = "StringList" +_SS = "StringSet" +_TL = "TimestampList" +n1 = "aws.protocoltests.restxml" +_AQSTI = "AllQueryStringTypesInput" +_qS = "queryString" +_sQ = "smithy.api#httpQuery" +_S = "String" +_qSL = "queryStringList" +_qSS = "queryStringSet" +_qB = "queryByte" +_By = "Byte" +_qSu = "queryShort" +_Sh = "Short" +_qI = "queryInteger" +_I = "Integer" +_qIL = "queryIntegerList" +_qIS = "queryIntegerSet" +_qL = "queryLong" +_L = "Long" +_qF = "queryFloat" +_F = "Float" +_qD = "queryDouble" +_D = "Double" +_qDL = "queryDoubleList" +_qBu = "queryBoolean" +_Bo = "Boolean" +_qBL = "queryBooleanList" +_qT = "queryTimestamp" +_T = "Timestamp" +_qTL = "queryTimestampList" +_qE = "queryEnum" +_E = "Enum" +_qEL = "queryEnumList" +_EL = "EnumList" +_qIE = "queryIntegerEnum" +_qIEL = "queryIntegerEnumList" +_qPMOS = "queryParamsMapOfStrings" +_sQP = "smithy.api#httpQueryParams" +_AQSTO = "AllQueryStringTypesOutput" +_sSI = "smithy.synthetic#originalShapeId" +_sU = "smithy.api#Unit" +_AQST = "AllQueryStringTypes" +_s = "smithy.api#http" +_PWXN = "PayloadWithXmlName" +_sN = "smithy.api#xmlName" +_H = "Hello" +_n = "name" +_BWXNI = "BodyWithXmlNameInput" +_Ah = "Ahoy" +_aBWXNIO = "aws.protocoltests.restxml#BodyWithXmlNameInputOutput" +_ne = "nested" +_BWXNO = "BodyWithXmlNameOutput" +_BWXN = "BodyWithXmlName" +_CNED = "ComplexNestedErrorData" +_Fo = "Foo" +_CE = "ComplexError" +_sm = "smithy.api#error" +_c = "client" +_sE = "smithy.api#httpError" +_He = "Header" +_sH = "smithy.api#httpHeader" +_XH = "X-Header" +_TLo = "TopLevel" +_N = "Nested" +_CAVQSI = "ConstantAndVariableQueryStringInput" +_b = "baz" +_mS = "maybeSet" +_CAVQSO = "ConstantAndVariableQueryStringOutput" +_CAVQS = "ConstantAndVariableQueryString" +_CQSI = "ConstantQueryStringInput" +_h = "hello" +_smi = "smithy.api#required" +_sL = "smithy.api#httpLabel" +_CQSO = "ConstantQueryStringOutput" +_CQS = "ConstantQueryString" +_CTPI = "ContentTypeParametersInput" +_CTPO = "ContentTypeParametersOutput" +_CTP = "ContentTypeParameters" +_DOI = "DatetimeOffsetsInput" +_DT = "DateTime" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_DOO = "DatetimeOffsetsOutput" +_d = "datetime" +_DO = "DatetimeOffsets" +_EIAEOI = "EmptyInputAndEmptyOutputInput" +_EIAEOO = "EmptyInputAndEmptyOutputOutput" +_EIAEO = "EmptyInputAndEmptyOutput" +_EOI = "EndpointOperationInput" +_EOO = "EndpointOperationOutput" +_EO = "EndpointOperation" +_smit = "smithy.api#endpoint" +_EWHLHOI = "EndpointWithHostLabelHeaderOperationInput" +_aHLHI = "aws.protocoltests.restxml#HostLabelHeaderInput" +_aI = "accountId" +_sLm = "smithy.api#hostLabel" +_XAAI = "X-Amz-Account-Id" +_EWHLHOO = "EndpointWithHostLabelHeaderOperationOutput" +_EWHLHO = "EndpointWithHostLabelHeaderOperation" +_EWHLOI = "EndpointWithHostLabelOperationInput" +_aEWHLOR = "aws.protocoltests.restxml#EndpointWithHostLabelOperationRequest" +_l = "label" +_EWHLOO = "EndpointWithHostLabelOperationOutput" +_EWHLO = "EndpointWithHostLabelOperation" +_FEM = "FooEnumMap" +_FXMI = "FlattenedXmlMapInput" +_aFXMR = "aws.protocoltests.restxml#FlattenedXmlMapRequest" +_mM = "myMap" +_sFm = "smithy.api#xmlFlattened" +_FXMO = "FlattenedXmlMapOutput" +_aFXMRw = "aws.protocoltests.restxml#FlattenedXmlMapResponse" +_FXM = "FlattenedXmlMap" +_FXMWXNIOM = "FlattenedXmlMapWithXmlNameInputOutputMap" +_K = "K" +_V = "V" +_FXMWXNI = "FlattenedXmlMapWithXmlNameInput" +_aFXMWXNR = "aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameRequest" +_KVP = "KVP" +_FXMWXNO = "FlattenedXmlMapWithXmlNameOutput" +_aFXMWXNRw = "aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameResponse" +_FXMWXN = "FlattenedXmlMapWithXmlName" +_FXMWXNIl = "FlattenedXmlMapWithXmlNamespaceInput" +_FXMWXNOM = "FlattenedXmlMapWithXmlNamespaceOutputMap" +_sNm = "smithy.api#xmlNamespace" +_FXMWXNOl = "FlattenedXmlMapWithXmlNamespaceOutput" +_FXMWXNl = "FlattenedXmlMapWithXmlNamespace" +_FPH = "FooPrefixHeaders" +_FSI = "FractionalSecondsInput" +_FSO = "FractionalSecondsOutput" +_FS = "FractionalSeconds" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_g = "greeting" +_XG = "X-Greeting" +_IG = "InvalidGreeting" +_M = "Message" +_GWE = "GreetingWithErrors" +_HEPHI = "HttpEmptyPrefixHeadersInput" +_pH = "prefixHeaders" +_sPH = "smithy.api#httpPrefixHeaders" +_v_ = "" +_sHp = "specificHeader" +_HEPHO = "HttpEmptyPrefixHeadersOutput" +_HEPH = "HttpEmptyPrefixHeaders" +_SE = "StringEnum" +_HEPI = "HttpEnumPayloadInput" +_aEPI = "aws.protocoltests.restxml#EnumPayloadInput" +_p = "payload" +_sP = "smithy.api#httpPayload" +_HEPO = "HttpEnumPayloadOutput" +_HEP = "HttpEnumPayload" +_HPTI = "HttpPayloadTraitsInput" +_aHPTIO = "aws.protocoltests.restxml#HttpPayloadTraitsInputOutput" +_f = "foo" +_XF = "X-Foo" +_bl = "blob" +_HPTO = "HttpPayloadTraitsOutput" +_HPT = "HttpPayloadTraits" +_TPB = "TextPlainBlob" +_sT = "smithy.api#mediaType" +_t = "text/plain" +_HPTWMTI = "HttpPayloadTraitsWithMediaTypeInput" +_aHPTWMTIO = "aws.protocoltests.restxml#HttpPayloadTraitsWithMediaTypeInputOutput" +_HPTWMTO = "HttpPayloadTraitsWithMediaTypeOutput" +_HPTWMT = "HttpPayloadTraitsWithMediaType" +_HPWMXNI = "HttpPayloadWithMemberXmlNameInput" +_aHPWMXNIO = "aws.protocoltests.restxml#HttpPayloadWithMemberXmlNameInputOutput" +_Ho = "Hola" +_HPWMXNO = "HttpPayloadWithMemberXmlNameOutput" +_HPWMXN = "HttpPayloadWithMemberXmlName" +_NP = "NestedPayload" +_HPWSI = "HttpPayloadWithStructureInput" +_aHPWSIO = "aws.protocoltests.restxml#HttpPayloadWithStructureInputOutput" +_HPWSO = "HttpPayloadWithStructureOutput" +_HPWS = "HttpPayloadWithStructure" +_UP = "UnionPayload" +_HPWUI = "HttpPayloadWithUnionInput" +_aHPWUIO = "aws.protocoltests.restxml#HttpPayloadWithUnionInputOutput" +_HPWUO = "HttpPayloadWithUnionOutput" +_HPWU = "HttpPayloadWithUnion" +_HPWXNI = "HttpPayloadWithXmlNameInput" +_aHPWXNIO = "aws.protocoltests.restxml#HttpPayloadWithXmlNameInputOutput" +_HPWXNO = "HttpPayloadWithXmlNameOutput" +_HPWXN = "HttpPayloadWithXmlName" +_PWXNa = "PayloadWithXmlNamespace" +_HPWXNIt = "HttpPayloadWithXmlNamespaceInput" +_aHPWXNIOw = "aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceInputOutput" +_HPWXNOt = "HttpPayloadWithXmlNamespaceOutput" +_HPWXNt = "HttpPayloadWithXmlNamespace" +_PWXNAP = "PayloadWithXmlNamespaceAndPrefix" +_HPWXNAPI = "HttpPayloadWithXmlNamespaceAndPrefixInput" +_aHPWXNAPIO = ( + "aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceAndPrefixInputOutput" +) +_HPWXNAPO = "HttpPayloadWithXmlNamespaceAndPrefixOutput" +_HPWXNAP = "HttpPayloadWithXmlNamespaceAndPrefix" +_HPHI = "HttpPrefixHeadersInput" +_aHPHIO = "aws.protocoltests.restxml#HttpPrefixHeadersInputOutput" +_xf = "x-foo" +_fM = "fooMap" +_xf_ = "x-foo-" +_HPHO = "HttpPrefixHeadersOutput" +_HPH = "HttpPrefixHeaders" +_HRWFLI = "HttpRequestWithFloatLabelsInput" +_fl = "float" +_do = "double" +_HRWFLO = "HttpRequestWithFloatLabelsOutput" +_HRWFL = "HttpRequestWithFloatLabels" +_HRWGLIPI = "HttpRequestWithGreedyLabelInPathInput" +_HRWGLIPO = "HttpRequestWithGreedyLabelInPathOutput" +_HRWGLIP = "HttpRequestWithGreedyLabelInPath" +_HRWLI = "HttpRequestWithLabelsInput" +_st = "string" +_sh = "short" +_i = "integer" +_lo = "long" +_bo = "boolean" +_ti = "timestamp" +_HRWLO = "HttpRequestWithLabelsOutput" +_HRWL = "HttpRequestWithLabels" +_ES = "EpochSeconds" +_es = "epoch-seconds" +_HD = "HttpDate" +_hd = "http-date" +_HRWLATFI = "HttpRequestWithLabelsAndTimestampFormatInput" +_mES = "memberEpochSeconds" +_mHD = "memberHttpDate" +_mDT = "memberDateTime" +_dF = "defaultFormat" +_tES = "targetEpochSeconds" +_tHD = "targetHttpDate" +_tDT = "targetDateTime" +_HRWLATFO = "HttpRequestWithLabelsAndTimestampFormatOutput" +_HRWLATF = "HttpRequestWithLabelsAndTimestampFormat" +_HRCI = "HttpResponseCodeInput" +_HRCO = "HttpResponseCodeOutput" +_St = "Status" +_sRC = "smithy.api#httpResponseCode" +_HRC = "HttpResponseCode" +_HSPI = "HttpStringPayloadInput" +_aSPI = "aws.protocoltests.restxml#StringPayloadInput" +_HSPO = "HttpStringPayloadOutput" +_HSP = "HttpStringPayload" +_IQPIRI = "IgnoreQueryParamsInResponseInput" +_IQPIRO = "IgnoreQueryParamsInResponseOutput" +_IQPIR = "IgnoreQueryParamsInResponse" +_IAOWHI = "InputAndOutputWithHeadersInput" +_aIAOWHIO = "aws.protocoltests.restxml#InputAndOutputWithHeadersIO" +_hS = "headerString" +_XS = "X-String" +_hB = "headerByte" +_XB = "X-Byte" +_hSe = "headerShort" +_XS_ = "X-Short" +_hI = "headerInteger" +_XI = "X-Integer" +_hL = "headerLong" +_XL = "X-Long" +_hF = "headerFloat" +_XF_ = "X-Float" +_hD = "headerDouble" +_XD = "X-Double" +_hTB = "headerTrueBool" +_XB_ = "X-Boolean1" +_hFB = "headerFalseBool" +_XB__ = "X-Boolean2" +_hSL = "headerStringList" +_XS__ = "X-StringList" +_hSS = "headerStringSet" +_XS___ = "X-StringSet" +_hIL = "headerIntegerList" +_XI_ = "X-IntegerList" +_hBL = "headerBooleanList" +_XB___ = "X-BooleanList" +_hTL = "headerTimestampList" +_XT = "X-TimestampList" +_hE = "headerEnum" +_XE = "X-Enum" +_hEL = "headerEnumList" +_XE_ = "X-EnumList" +_IAOWHO = "InputAndOutputWithHeadersOutput" +_IAOWH = "InputAndOutputWithHeaders" +_LWMN = "ListWithMemberNamespace" +_LWN = "ListWithNamespace" +_NM = "NestedMap" +_NXMI = "NestedXmlMapsInput" +_aNXMR = "aws.protocoltests.restxml#NestedXmlMapsRequest" +_nM = "nestedMap" +_fNM = "flatNestedMap" +_NXMO = "NestedXmlMapsOutput" +_aNXMRw = "aws.protocoltests.restxml#NestedXmlMapsResponse" +_NXM = "NestedXmlMaps" +_NXMWXNIM = "NestedXmlMapWithXmlNameInnerMap" +_IK = "InnerKey" +_IV = "InnerValue" +_NXMWXNM = "NestedXmlMapWithXmlNameMap" +_OK = "OuterKey" +_NXMWXNI = "NestedXmlMapWithXmlNameInput" +_aNXMWXNR = "aws.protocoltests.restxml#NestedXmlMapWithXmlNameRequest" +_nXMWXNM = "nestedXmlMapWithXmlNameMap" +_NXMWXNO = "NestedXmlMapWithXmlNameOutput" +_aNXMWXNRw = "aws.protocoltests.restxml#NestedXmlMapWithXmlNameResponse" +_NXMWXN = "NestedXmlMapWithXmlName" +_NIANOI = "NoInputAndNoOutputInput" +_NIANOO = "NoInputAndNoOutputOutput" +_NIANO = "NoInputAndNoOutput" +_NIAOI = "NoInputAndOutputInput" +_NIAOO = "NoInputAndOutputOutput" +_NIAO = "NoInputAndOutput" +_NAEHCI = "NullAndEmptyHeadersClientInput" +_aNAEHIO = "aws.protocoltests.restxml#NullAndEmptyHeadersIO" +_a = "a" +_XA = "X-A" +_b_ = "b" +_XB____ = "X-B" +_c_ = "c" +_XC = "X-C" +_NAEHCO = "NullAndEmptyHeadersClientOutput" +_NAEHC = "NullAndEmptyHeadersClient" +_NAEHSI = "NullAndEmptyHeadersServerInput" +_NAEHSO = "NullAndEmptyHeadersServerOutput" +_NAEHS = "NullAndEmptyHeadersServer" +_ONSESI = "OmitsNullSerializesEmptyStringInput" +_nV = "nullValue" +_Nu = "Null" +_eS = "emptyString" +_Em = "Empty" +_ONSESO = "OmitsNullSerializesEmptyStringOutput" +_ONSES = "OmitsNullSerializesEmptyString" +_PWCEI = "PutWithContentEncodingInput" +_e = "encoding" +_CE_ = "Content-Encoding" +_da = "data" +_PWCEO = "PutWithContentEncodingOutput" +_PWCE = "PutWithContentEncoding" +_sC = "smithy.api#requestCompression" +_QITAFI = "QueryIdempotencyTokenAutoFillInput" +_to = "token" +_sTm = "smithy.api#idempotencyToken" +_QITAFO = "QueryIdempotencyTokenAutoFillOutput" +_QITAF = "QueryIdempotencyTokenAutoFill" +_SLM = "StringListMap" +_QPASLMI = "QueryParamsAsStringListMapInput" +_q = "qux" +_co = "corge" +_QPASLMO = "QueryParamsAsStringListMapOutput" +_QPASLM = "QueryParamsAsStringListMap" +_QPI = "QueryPrecedenceInput" +_ba = "bar" +_QPO = "QueryPrecedenceOutput" +_QP = "QueryPrecedence" +_RLM = "RenamedListMembers" +_it = "item" +_SSPI = "SimpleScalarPropertiesInput" +_aSSPR = "aws.protocoltests.restxml#SimpleScalarPropertiesRequest" +_sV = "stringValue" +_tBV = "trueBooleanValue" +_fBV = "falseBooleanValue" +_bV = "byteValue" +_sVh = "shortValue" +_iV = "integerValue" +_lV = "longValue" +_fV = "floatValue" +_dV = "doubleValue" +_DD = "DoubleDribble" +_SSPO = "SimpleScalarPropertiesOutput" +_aSSPRw = "aws.protocoltests.restxml#SimpleScalarPropertiesResponse" +_SSP = "SimpleScalarProperties" +_TFHI = "TimestampFormatHeadersInput" +_aTFHIO = "aws.protocoltests.restxml#TimestampFormatHeadersIO" +_Xm = "X-memberEpochSeconds" +_Xm_ = "X-memberHttpDate" +_Xm__ = "X-memberDateTime" +_Xd = "X-defaultFormat" +_Xt = "X-targetEpochSeconds" +_Xt_ = "X-targetHttpDate" +_Xt__ = "X-targetDateTime" +_TFHO = "TimestampFormatHeadersOutput" +_TFH = "TimestampFormatHeaders" +_XAI = "XmlAttributesInput" +_aXAR = "aws.protocoltests.restxml#XmlAttributesRequest" +_at = "attr" +_te = "test" +_sA = "smithy.api#xmlAttribute" +_XAO = "XmlAttributesOutput" +_aXARw = "aws.protocoltests.restxml#XmlAttributesResponse" +_XAm = "XmlAttributes" +_XAIMPR = "XmlAttributesInMiddlePayloadRequest" +_XAIMI = "XmlAttributesInMiddleInput" +_aXAIMR = "aws.protocoltests.restxml#XmlAttributesInMiddleRequest" +_XAIMPRm = "XmlAttributesInMiddlePayloadResponse" +_XAIMO = "XmlAttributesInMiddleOutput" +_aXAIMRw = "aws.protocoltests.restxml#XmlAttributesInMiddleResponse" +_XAIM = "XmlAttributesInMiddle" +_XAPR = "XmlAttributesPayloadRequest" +_XAOPI = "XmlAttributesOnPayloadInput" +_aXAOPR = "aws.protocoltests.restxml#XmlAttributesOnPayloadRequest" +_XAPRm = "XmlAttributesPayloadResponse" +_XAOPO = "XmlAttributesOnPayloadOutput" +_aXAOPRw = "aws.protocoltests.restxml#XmlAttributesOnPayloadResponse" +_XAOP = "XmlAttributesOnPayload" +_XBI = "XmlBlobsInput" +_aXBR = "aws.protocoltests.restxml#XmlBlobsRequest" +_XBO = "XmlBlobsOutput" +_aXBRw = "aws.protocoltests.restxml#XmlBlobsResponse" +_XBm = "XmlBlobs" +_XEBI = "XmlEmptyBlobsInput" +_aXEBR = "aws.protocoltests.restxml#XmlEmptyBlobsRequest" +_XEBO = "XmlEmptyBlobsOutput" +_aXEBRw = "aws.protocoltests.restxml#XmlEmptyBlobsResponse" +_XEB = "XmlEmptyBlobs" +_SLMt = "StructureListMember" +_o = "other" +_SLt = "StructureList" +_NSL = "NestedStringList" +_XELI = "XmlEmptyListsInput" +_aXELR = "aws.protocoltests.restxml#XmlEmptyListsRequest" +_sLt = "stringList" +_sS = "stringSet" +_iL = "integerList" +_bL = "booleanList" +_tL = "timestampList" +_eL = "enumList" +_iEL = "intEnumList" +_nSL = "nestedStringList" +_rLM = "renamedListMembers" +_r = "renamed" +_fL = "flattenedList" +_fLl = "flattenedList2" +_cN = "customName" +_fLWMN = "flattenedListWithMemberNamespace" +_fLWN = "flattenedListWithNamespace" +_sLtr = "structureList" +_mSL = "myStructureList" +_fSL = "flattenedStructureList" +_XELO = "XmlEmptyListsOutput" +_aXELRw = "aws.protocoltests.restxml#XmlEmptyListsResponse" +_XEL = "XmlEmptyLists" +_GS = "GreetingStruct" +_hi = "hi" +_XMIOM = "XmlMapsInputOutputMap" +_XEMI = "XmlEmptyMapsInput" +_aXEMR = "aws.protocoltests.restxml#XmlEmptyMapsRequest" +_XEMO = "XmlEmptyMapsOutput" +_aXEMRw = "aws.protocoltests.restxml#XmlEmptyMapsResponse" +_XEM = "XmlEmptyMaps" +_XESI = "XmlEmptyStringsInput" +_aXESR = "aws.protocoltests.restxml#XmlEmptyStringsRequest" +_XESO = "XmlEmptyStringsOutput" +_aXESRw = "aws.protocoltests.restxml#XmlEmptyStringsResponse" +_XES = "XmlEmptyStrings" +_FES = "FooEnumSet" +_XEI = "XmlEnumsInput" +_aXER = "aws.protocoltests.restxml#XmlEnumsRequest" +_fE = "fooEnum1" +_fEo = "fooEnum2" +_fEoo = "fooEnum3" +_fEL = "fooEnumList" +_fES = "fooEnumSet" +_fEM = "fooEnumMap" +_XEO = "XmlEnumsOutput" +_aXERw = "aws.protocoltests.restxml#XmlEnumsResponse" +_XEm = "XmlEnums" +_IEM = "IntegerEnumMap" +_IES = "IntegerEnumSet" +_XIEI = "XmlIntEnumsInput" +_aXIER = "aws.protocoltests.restxml#XmlIntEnumsRequest" +_iE = "intEnum1" +_iEn = "intEnum2" +_iEnt = "intEnum3" +_iES = "intEnumSet" +_iEM = "intEnumMap" +_XIEO = "XmlIntEnumsOutput" +_aXIERw = "aws.protocoltests.restxml#XmlIntEnumsResponse" +_XIE = "XmlIntEnums" +_XLI = "XmlListsInput" +_aXLR = "aws.protocoltests.restxml#XmlListsRequest" +_XLO = "XmlListsOutput" +_aXLRw = "aws.protocoltests.restxml#XmlListsResponse" +_XLm = "XmlLists" +_XMI = "XmlMapsInput" +_aXMR = "aws.protocoltests.restxml#XmlMapsRequest" +_XMO = "XmlMapsOutput" +_aXMRw = "aws.protocoltests.restxml#XmlMapsResponse" +_XM = "XmlMaps" +_XMXNIOM = "XmlMapsXmlNameInputOutputMap" +_At = "Attribute" +_Se = "Setting" +_XMXNI = "XmlMapsXmlNameInput" +_aXMXNR = "aws.protocoltests.restxml#XmlMapsXmlNameRequest" +_XMXNO = "XmlMapsXmlNameOutput" +_aXMXNRw = "aws.protocoltests.restxml#XmlMapsXmlNameResponse" +_XMXN = "XmlMapsXmlName" +_XMWXNIOM = "XmlMapWithXmlNamespaceInputOutputMap" +_XMWXNI = "XmlMapWithXmlNamespaceInput" +_aXMWXNR = "aws.protocoltests.restxml#XmlMapWithXmlNamespaceRequest" +_XMWXNO = "XmlMapWithXmlNamespaceOutput" +_aXMWXNRw = "aws.protocoltests.restxml#XmlMapWithXmlNamespaceResponse" +_XMWXN = "XmlMapWithXmlNamespace" +_XNL = "XmlNamespacedList" +_XNN = "XmlNamespaceNested" +_va = "values" +_XNI = "XmlNamespacesInput" +_aXNR = "aws.protocoltests.restxml#XmlNamespacesRequest" +_XNO = "XmlNamespacesOutput" +_aXNRw = "aws.protocoltests.restxml#XmlNamespacesResponse" +_XN = "XmlNamespaces" +_XTI = "XmlTimestampsInput" +_aXTR = "aws.protocoltests.restxml#XmlTimestampsRequest" +_no = "normal" +_dT = "dateTime" +_dTOT = "dateTimeOnTarget" +_eSp = "epochSeconds" +_eSOT = "epochSecondsOnTarget" +_hDt = "httpDate" +_hDOT = "httpDateOnTarget" +_XTO = "XmlTimestampsOutput" +_aXTRw = "aws.protocoltests.restxml#XmlTimestampsResponse" +_XTm = "XmlTimestamps" +_XNUS = "XmlNestedUnionStruct" +_bVo = "booleanValue" +_XUS = "XmlUnionShape" +_uV = "unionValue" +_sVt = "structValue" +_RSION = "RecursiveShapesInputOutputNested1" +_RSIONe = "RecursiveShapesInputOutputNested2" +_rM = "recursiveMember" +_XUI = "XmlUnionsInput" +_aXUR = "aws.protocoltests.restxml#XmlUnionsRequest" +_XUO = "XmlUnionsOutput" +_aXURw = "aws.protocoltests.restxml#XmlUnionsResponse" +_RSI = "RecursiveShapesInput" +_aRSR = "aws.protocoltests.restxml#RecursiveShapesRequest" +_RSO = "RecursiveShapesOutput" +_aRSRw = "aws.protocoltests.restxml#RecursiveShapesResponse" +_XU = "XmlUnions" +_RS = "RecursiveShapes" +_RX = "RestXml" +_aw = "aws.auth#sigv4" +_aX = "aws.protocols#restXml" +_sB = "smithy.rules#endpointBdd" +_aws = "aws.api#service" + +BOOLEAN_LIST = (16, n0, _BL, 0, (_m,), ((2, 0),)) + +DOUBLE_LIST = (16, n0, _DL, 0, (_m,), ((10, 0),)) + +FOO_ENUM = ( + 14, + n0, + _FE, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +FOO_ENUM_LIST = (16, n0, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) + +INTEGER_ENUM = (15, n0, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) + +INTEGER_ENUM_LIST = (16, n0, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) + +INTEGER_LIST = (16, n0, _IL, 0, (_m,), ((7, 0),)) + +INTEGER_SET = (16, n0, _IS, 0, (_m,), ((7, 0),)) + +STRING_MAP = (17, n0, _SM, 0, (_k, _v), ((3, 0), (3, 0))) + +STRING_LIST = (16, n0, _SL, 0, (_m,), ((3, 0),)) + +STRING_SET = (16, n0, _SS, 0, (_m,), ((3, 0),)) + +TIMESTAMP_LIST = (16, n0, _TL, 0, (_m,), ((4, 0),)) + +ALL_QUERY_STRING_TYPES_INPUT = ( + 18, + n1, + _AQSTI, + 0, + ( + _qS, + _qSL, + _qSS, + _qB, + _qSu, + _qI, + _qIL, + _qIS, + _qL, + _qF, + _qD, + _qDL, + _qBu, + _qBL, + _qT, + _qTL, + _qE, + _qEL, + _qIE, + _qIEL, + _qPMOS, + ), + ( + (3, {_sQ: _S}), + (STRING_LIST, {_sQ: _SL}), + (STRING_SET, {_sQ: _SS}), + (5, {_sQ: _By}), + (6, {_sQ: _Sh}), + (7, {_sQ: _I}), + (INTEGER_LIST, {_sQ: _IL}), + (INTEGER_SET, {_sQ: _IS}), + (8, {_sQ: _L}), + (9, {_sQ: _F}), + (10, {_sQ: _D}), + (DOUBLE_LIST, {_sQ: _DL}), + (2, {_sQ: _Bo}), + (BOOLEAN_LIST, {_sQ: _BL}), + (4, {_sQ: _T}), + (TIMESTAMP_LIST, {_sQ: _TL}), + (FOO_ENUM, {_sQ: _E}), + (FOO_ENUM_LIST, {_sQ: _EL}), + (INTEGER_ENUM, {_sQ: _IE}), + (INTEGER_ENUM_LIST, {_sQ: _IEL}), + (STRING_MAP, 1024), + ), ) -ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EndpointWithHostLabelHeaderOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HostLabelHeaderInput", - ) - ], - members={ - "accountId": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-Amz-Account-Id" - ), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, -) +ALL_QUERY_STRING_TYPES_OUTPUT = (18, n1, _AQSTO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EndpointWithHostLabelHeaderOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +ALL_QUERY_STRING_TYPES = ( + 23, + n1, + _AQST, + {_s: MappingProxyType({"uri": "/AllQueryStringTypesInput", "method": "GET"})}, + ALL_QUERY_STRING_TYPES_INPUT, + ALL_QUERY_STRING_TYPES_OUTPUT, + (), ) -ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restxml#EndpointWithHostLabelHeaderOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "{accountId}."}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/EndpointWithHostLabelHeaderOperation", "method": "POST"} - ), - ), - ], -) +PAYLOAD_WITH_XML_NAME = (18, n1, _PWXN, {_sN: _H}, (_n,), ((3, 0),)) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EndpointWithHostLabelOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#EndpointWithHostLabelOperationRequest", - ) - ], - members={ - "label": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#hostLabel")), - Trait.new(id=ShapeID("smithy.api#required")), - ], - } - }, +BODY_WITH_XML_NAME_INPUT = ( + 18, + n1, + _BWXNI, + {_sN: _Ah, _sSI: _aBWXNIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAME, 0),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#EndpointWithHostLabelOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +BODY_WITH_XML_NAME_OUTPUT = ( + 18, + n1, + _BWXNO, + {_sN: _Ah, _sSI: _aBWXNIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAME, 0),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION = Schema( - id=ShapeID("aws.protocoltests.restxml#EndpointWithHostLabelOperation"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#endpoint"), - value=MappingProxyType({"hostPrefix": "foo.{label}."}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/EndpointWithHostLabelOperation", "method": "POST"} - ), - ), - ], +BODY_WITH_XML_NAME = ( + 23, + n1, + _BWXN, + {_s: MappingProxyType({"uri": "/BodyWithXmlName", "method": "PUT"})}, + BODY_WITH_XML_NAME_INPUT, + BODY_WITH_XML_NAME_OUTPUT, + (), ) -FOO_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": FOO_ENUM}}, -) +COMPLEX_NESTED_ERROR_DATA = (18, n1, _CNED, 0, (_Fo,), ((3, 0),)) -FLATTENED_XML_MAP_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#FlattenedXmlMapRequest", - ) - ], - members={ - "myMap": { - "target": FOO_ENUM_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - } - }, +COMPLEX_ERROR = ( + 18, + n1, + _CE, + {_sm: _c, _sE: 403}, + (_He, _TLo, _N), + ((3, {_sH: _XH}), (3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -FLATTENED_XML_MAP_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#FlattenedXmlMapResponse", - ) - ], - members={ - "myMap": { - "target": FOO_ENUM_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - } - }, +CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT = ( + 18, + n1, + _CAVQSI, + 0, + (_b, _mS), + ((3, {_sQ: _b}), (3, {_sQ: _mS})), ) -FLATTENED_XML_MAP = Schema( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMap"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/FlattenedXmlMap", "method": "POST"}), - ) - ], -) - -FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameInputOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="K")], - }, - "value": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="V")], - }, - }, -) +CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT = (18, n1, _CAVQSO, {_sSI: _sU}) -FLATTENED_XML_MAP_WITH_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameRequest", +CONSTANT_AND_VARIABLE_QUERY_STRING = ( + 23, + n1, + _CAVQS, + { + _s: MappingProxyType( + {"uri": "/ConstantAndVariableQueryString?foo=bar", "method": "GET"} ) - ], - members={ - "myMap": { - "target": FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - } }, + CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, + CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, + (), ) -FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#FlattenedXmlMapWithXmlNameResponse", - ) - ], - members={ - "myMap": { - "target": FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - } - }, -) +CONSTANT_QUERY_STRING_INPUT = (18, n1, _CQSI, 0, (_h,), ((3, 9),)) -FLATTENED_XML_MAP_WITH_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/FlattenedXmlMapWithXmlName", "method": "POST"} - ), - ) - ], -) +CONSTANT_QUERY_STRING_OUTPUT = (18, n1, _CQSO, {_sSI: _sU}) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNamespaceInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" +CONSTANT_QUERY_STRING = ( + 23, + n1, + _CQS, + { + _s: MappingProxyType( + {"uri": "/ConstantQueryString/{hello}?foo=bar&hello", "method": "GET"} ) - ], -) - -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNamespaceOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="K"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-key.example.com"}), - ), - ], - }, - "value": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="V"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-value.example.com"}), - ), - ], - }, - }, -) - -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNamespaceOutput"), - members={ - "myMap": { - "target": FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-member.example.com"}), - ), - ], - } }, + CONSTANT_QUERY_STRING_INPUT, + CONSTANT_QUERY_STRING_OUTPUT, + (), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE = Schema( - id=ShapeID("aws.protocoltests.restxml#FlattenedXmlMapWithXmlNamespace"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/FlattenedXmlMapWithXmlNamespace", "method": "POST"} - ), - ) - ], -) +CONTENT_TYPE_PARAMETERS_INPUT = (18, n1, _CTPI, 0, (_v,), ((7, 0),)) -FOO_PREFIX_HEADERS = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FooPrefixHeaders"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) +CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n1, _CTPO, 0) -FRACTIONAL_SECONDS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FractionalSecondsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +CONTENT_TYPE_PARAMETERS = ( + 23, + n1, + _CTP, + {_s: MappingProxyType({"uri": "/ContentTypeParameters", "method": "PUT"})}, + CONTENT_TYPE_PARAMETERS_INPUT, + CONTENT_TYPE_PARAMETERS_OUTPUT, + (), ) -FRACTIONAL_SECONDS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#FractionalSecondsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) +DATETIME_OFFSETS_INPUT = (18, n1, _DOI, {_sSI: _sU}) -FRACTIONAL_SECONDS = Schema( - id=ShapeID("aws.protocoltests.restxml#FractionalSeconds"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/FractionalSeconds", "method": "POST"}), - ) - ], -) +DATE_TIME = (4, n0, _DT, {_sF: _dt}) -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#GreetingWithErrorsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#GreetingWithErrorsOutput"), - members={ - "greeting": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Greeting") - ], - } - }, -) +DATETIME_OFFSETS_OUTPUT = (18, n1, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -INVALID_GREETING = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#InvalidGreeting"), - traits=[ - Trait.new(id=ShapeID("smithy.api#error"), value="client"), - Trait.new(id=ShapeID("smithy.api#httpError"), value=400), - ], - members={"Message": {"target": STRING}}, +DATETIME_OFFSETS = ( + 23, + n1, + _DO, + {_s: MappingProxyType({"uri": "/DatetimeOffsets", "method": "POST"})}, + DATETIME_OFFSETS_INPUT, + DATETIME_OFFSETS_OUTPUT, + (), ) -GREETING_WITH_ERRORS = Schema( - id=ShapeID("aws.protocoltests.restxml#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/GreetingWithErrors", "method": "PUT"}), - ) - ], -) - -HTTP_EMPTY_PREFIX_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpEmptyPrefixHeadersInput"), - members={ - "prefixHeaders": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="")], - }, - "specificHeader": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="hello")], - }, - }, -) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n1, _EIAEOI, 0) -HTTP_EMPTY_PREFIX_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpEmptyPrefixHeadersOutput"), - members={ - "prefixHeaders": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="")], - }, - "specificHeader": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="hello")], - }, - }, -) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n1, _EIAEOO, 0) -HTTP_EMPTY_PREFIX_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpEmptyPrefixHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpEmptyPrefixHeaders", "method": "GET"}), - ) - ], +EMPTY_INPUT_AND_EMPTY_OUTPUT = ( + 23, + n1, + _EIAEO, + {_s: MappingProxyType({"uri": "/EmptyInputAndEmptyOutput", "method": "POST"})}, + EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, + EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + (), ) -STRING_ENUM = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#StringEnum"), - shape_type=ShapeType.ENUM, - members={"V": {"target": UNIT}}, -) +ENDPOINT_OPERATION_INPUT = (18, n1, _EOI, {_sSI: _sU}) -HTTP_ENUM_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpEnumPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#EnumPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +ENDPOINT_OPERATION_OUTPUT = (18, n1, _EOO, {_sSI: _sU}) -HTTP_ENUM_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpEnumPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#EnumPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } +ENDPOINT_OPERATION = ( + 23, + n1, + _EO, + { + _smit: MappingProxyType({"hostPrefix": "foo."}), + _s: MappingProxyType({"uri": "/EndpointOperation", "method": "POST"}), }, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), ) -HTTP_ENUM_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpEnumPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/EnumPayload", "method": "POST"}), - ) - ], +ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT = ( + 18, + n1, + _EWHLHOI, + {_sSI: _aHLHI}, + (_aI,), + ((3, {_sH: _XAAI, _sLm: None, _smi: None}),), ) -HTTP_PAYLOAD_TRAITS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadTraitsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadTraitsInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) +ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT = (18, n1, _EWHLHOO, {_sSI: _sU}) -HTTP_PAYLOAD_TRAITS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadTraitsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadTraitsInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, +ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION = ( + 23, + n1, + _EWHLHO, + { + _smit: MappingProxyType({"hostPrefix": "{accountId}."}), + _s: MappingProxyType( + {"uri": "/EndpointWithHostLabelHeaderOperation", "method": "POST"} + ), }, + ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT, + (), ) -HTTP_PAYLOAD_TRAITS = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadTraits"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPayloadTraits", "method": "POST"}), - ) - ], -) - -TEXT_PLAIN_BLOB = Schema( - id=ShapeID("aws.protocoltests.shared#TextPlainBlob"), - shape_type=ShapeType.BLOB, - traits=[Trait.new(id=ShapeID("smithy.api#mediaType"), value="text/plain")], +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( + 18, + n1, + _EWHLOI, + {_sSI: _aEWHLOR}, + (_l,), + ((3, 257),), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadTraitsWithMediaTypeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadTraitsWithMediaTypeInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": TEXT_PLAIN_BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, - }, -) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n1, _EWHLOO, {_sSI: _sU}) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadTraitsWithMediaTypeOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadTraitsWithMediaTypeInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "blob": { - "target": TEXT_PLAIN_BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - }, +ENDPOINT_WITH_HOST_LABEL_OPERATION = ( + 23, + n1, + _EWHLO, + { + _smit: MappingProxyType({"hostPrefix": "foo.{label}."}), + _s: MappingProxyType( + {"uri": "/EndpointWithHostLabelOperation", "method": "POST"} + ), }, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), +) + +FOO_ENUM_MAP = (17, n0, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) + +FLATTENED_XML_MAP_INPUT = ( + 18, + n1, + _FXMI, + {_sSI: _aFXMR}, + (_mM,), + ((FOO_ENUM_MAP, {_sFm: None}),), +) + +FLATTENED_XML_MAP_OUTPUT = ( + 18, + n1, + _FXMO, + {_sSI: _aFXMRw}, + (_mM,), + ((FOO_ENUM_MAP, {_sFm: None}),), +) + +FLATTENED_XML_MAP = ( + 23, + n1, + _FXM, + {_s: MappingProxyType({"uri": "/FlattenedXmlMap", "method": "POST"})}, + FLATTENED_XML_MAP_INPUT, + FLATTENED_XML_MAP_OUTPUT, + (), +) + +FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP = ( + 17, + n1, + _FXMWXNIOM, + 0, + (_k, _v), + ((3, {_sN: _K}), (3, {_sN: _V})), +) + +FLATTENED_XML_MAP_WITH_XML_NAME_INPUT = ( + 18, + n1, + _FXMWXNI, + {_sSI: _aFXMWXNR}, + (_mM,), + ((FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP, {_sN: _KVP, _sFm: None}),), +) + +FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT = ( + 18, + n1, + _FXMWXNO, + {_sSI: _aFXMWXNRw}, + (_mM,), + ((FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP, {_sN: _KVP, _sFm: None}),), +) + +FLATTENED_XML_MAP_WITH_XML_NAME = ( + 23, + n1, + _FXMWXN, + {_s: MappingProxyType({"uri": "/FlattenedXmlMapWithXmlName", "method": "POST"})}, + FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, + FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, + (), +) + +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT = (18, n1, _FXMWXNIl, {_sSI: _sU}) + +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP = ( + 17, + n1, + _FXMWXNOM, + 0, + (_k, _v), + ( + (3, {_sN: _K, _sNm: MappingProxyType({"uri": "https://the-key.example.com"})}), + ( + 3, + {_sN: _V, _sNm: MappingProxyType({"uri": "https://the-value.example.com"})}, + ), + ), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadTraitsWithMediaType"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadTraitsWithMediaType", "method": "POST"} - ), - ) - ], -) - -HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithMemberXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithMemberXmlNameInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="Hola"), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - } - }, +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT = ( + 18, + n1, + _FXMWXNOl, + 0, + (_mM,), + ( + ( + FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP, + { + _sN: _KVP, + _sFm: None, + _sNm: MappingProxyType({"uri": "https://the-member.example.com"}), + }, + ), + ), ) -HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithMemberXmlNameOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithMemberXmlNameInputOutput", +FLATTENED_XML_MAP_WITH_XML_NAMESPACE = ( + 23, + n1, + _FXMWXNl, + { + _s: MappingProxyType( + {"uri": "/FlattenedXmlMapWithXmlNamespace", "method": "POST"} ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="Hola"), - Trait.new(id=ShapeID("smithy.api#httpPayload")), - ], - } }, + FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, + FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, + (), ) -HTTP_PAYLOAD_WITH_MEMBER_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithMemberXmlName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadWithMemberXmlName", "method": "PUT"} - ), - ) - ], -) - -NESTED_PAYLOAD = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedPayload"), - members={"greeting": {"target": STRING}, "name": {"target": STRING}}, -) +FOO_PREFIX_HEADERS = (17, n1, _FPH, 0, (_k, _v), ((3, 0), (3, 0))) -HTTP_PAYLOAD_WITH_STRUCTURE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithStructureInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithStructureInputOutput", - ) - ], - members={ - "nested": { - "target": NESTED_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +FRACTIONAL_SECONDS_INPUT = (18, n1, _FSI, {_sSI: _sU}) -HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithStructureOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithStructureInputOutput", - ) - ], - members={ - "nested": { - "target": NESTED_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +FRACTIONAL_SECONDS_OUTPUT = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -HTTP_PAYLOAD_WITH_STRUCTURE = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithStructure"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadWithStructure", "method": "PUT"} - ), - ) - ], +FRACTIONAL_SECONDS = ( + 23, + n1, + _FS, + {_s: MappingProxyType({"uri": "/FractionalSeconds", "method": "POST"})}, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), ) -UNION_PAYLOAD = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#UnionPayload"), - shape_type=ShapeType.UNION, - members={"greeting": {"target": STRING}}, -) +GREETING_WITH_ERRORS_INPUT = (18, n1, _GWEI, {_sSI: _sU}) -HTTP_PAYLOAD_WITH_UNION_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithUnionInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithUnionInputOutput", - ) - ], - members={ - "nested": { - "target": UNION_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +GREETING_WITH_ERRORS_OUTPUT = (18, n1, _GWEO, 0, (_g,), ((3, {_sH: _XG}),)) -HTTP_PAYLOAD_WITH_UNION_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithUnionOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithUnionInputOutput", - ) - ], - members={ - "nested": { - "target": UNION_PAYLOAD, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +INVALID_GREETING = (18, n1, _IG, {_sm: _c, _sE: 400}, (_M,), ((3, 0),)) -HTTP_PAYLOAD_WITH_UNION = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithUnion"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPayloadWithUnion", "method": "PUT"}), - ) - ], +GREETING_WITH_ERRORS = ( + 23, + n1, + _GWE, + {_s: MappingProxyType({"uri": "/GreetingWithErrors", "method": "PUT"})}, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR), ) -HTTP_PAYLOAD_WITH_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithXmlNameInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +HTTP_EMPTY_PREFIX_HEADERS_INPUT = ( + 18, + n1, + _HEPHI, + 0, + (_pH, _sHp), + ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNameOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithXmlNameInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAME, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +HTTP_EMPTY_PREFIX_HEADERS_OUTPUT = ( + 18, + n1, + _HEPHO, + 0, + (_pH, _sHp), + ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -HTTP_PAYLOAD_WITH_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPayloadWithXmlName", "method": "PUT"}), - ) - ], +HTTP_EMPTY_PREFIX_HEADERS = ( + 23, + n1, + _HEPH, + {_s: MappingProxyType({"uri": "/HttpEmptyPrefixHeaders", "method": "GET"})}, + HTTP_EMPTY_PREFIX_HEADERS_INPUT, + HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, + (), ) -PAYLOAD_WITH_XML_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#PayloadWithXmlNamespace"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ) - ], - members={"name": {"target": STRING}}, -) +STRING_ENUM = (14, n1, _SE, 0, (_V,), ((-1, 0),)) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +HTTP_ENUM_PAYLOAD_INPUT = (18, n1, _HEPI, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +HTTP_ENUM_PAYLOAD_OUTPUT = (18, n1, _HEPO, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) -HTTP_PAYLOAD_WITH_XML_NAMESPACE = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNamespace"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadWithXmlNamespace", "method": "PUT"} - ), - ) - ], +HTTP_ENUM_PAYLOAD = ( + 23, + n1, + _HEP, + {_s: MappingProxyType({"uri": "/EnumPayload", "method": "POST"})}, + HTTP_ENUM_PAYLOAD_INPUT, + HTTP_ENUM_PAYLOAD_OUTPUT, + (), ) -PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#PayloadWithXmlNamespaceAndPrefix"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com", "prefix": "baz"}), - ) - ], - members={"name": {"target": STRING}}, +HTTP_PAYLOAD_TRAITS_INPUT = ( + 18, + n1, + _HPTI, + {_sSI: _aHPTIO}, + (_f, _bl), + ((3, {_sH: _XF}), (1, 16)), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceAndPrefixInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceAndPrefixInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +HTTP_PAYLOAD_TRAITS_OUTPUT = ( + 18, + n1, + _HPTO, + {_sSI: _aHPTIO}, + (_f, _bl), + ((3, {_sH: _XF}), (1, 16)), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceAndPrefixOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceAndPrefixInputOutput", - ) - ], - members={ - "nested": { - "target": PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) +HTTP_PAYLOAD_TRAITS = ( + 23, + n1, + _HPT, + {_s: MappingProxyType({"uri": "/HttpPayloadTraits", "method": "POST"})}, + HTTP_PAYLOAD_TRAITS_INPUT, + HTTP_PAYLOAD_TRAITS_OUTPUT, + (), +) + +TEXT_PLAIN_BLOB = (1, n0, _TPB, {_sT: _t}) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT = ( + 18, + n1, + _HPTWMTI, + {_sSI: _aHPTWMTIO}, + (_f, _bl), + ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), +) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPayloadWithXmlNamespaceAndPrefix"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/HttpPayloadWithXmlNamespaceAndPrefix", "method": "PUT"} - ), - ) - ], +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT = ( + 18, + n1, + _HPTWMTO, + {_sSI: _aHPTWMTIO}, + (_f, _bl), + ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), +) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = ( + 23, + n1, + _HPTWMT, + { + _s: MappingProxyType( + {"uri": "/HttpPayloadTraitsWithMediaType", "method": "POST"} + ) + }, + HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, + HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + (), +) + +HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT = ( + 18, + n1, + _HPWMXNI, + {_sSI: _aHPWMXNIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAME, {_sN: _Ho, _sP: None}),), +) + +HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT = ( + 18, + n1, + _HPWMXNO, + {_sSI: _aHPWMXNIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAME, {_sN: _Ho, _sP: None}),), +) + +HTTP_PAYLOAD_WITH_MEMBER_XML_NAME = ( + 23, + n1, + _HPWMXN, + {_s: MappingProxyType({"uri": "/HttpPayloadWithMemberXmlName", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT, + HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT, + (), +) + +NESTED_PAYLOAD = (18, n1, _NP, 0, (_g, _n), ((3, 0), (3, 0))) + +HTTP_PAYLOAD_WITH_STRUCTURE_INPUT = ( + 18, + n1, + _HPWSI, + {_sSI: _aHPWSIO}, + (_ne,), + ((NESTED_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT = ( + 18, + n1, + _HPWSO, + {_sSI: _aHPWSIO}, + (_ne,), + ((NESTED_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_STRUCTURE = ( + 23, + n1, + _HPWS, + {_s: MappingProxyType({"uri": "/HttpPayloadWithStructure", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, + HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, + (), +) + +UNION_PAYLOAD = (19, n1, _UP, 0, (_g,), ((3, 0),)) + +HTTP_PAYLOAD_WITH_UNION_INPUT = ( + 18, + n1, + _HPWUI, + {_sSI: _aHPWUIO}, + (_ne,), + ((UNION_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_UNION_OUTPUT = ( + 18, + n1, + _HPWUO, + {_sSI: _aHPWUIO}, + (_ne,), + ((UNION_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_UNION = ( + 23, + n1, + _HPWU, + {_s: MappingProxyType({"uri": "/HttpPayloadWithUnion", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_UNION_INPUT, + HTTP_PAYLOAD_WITH_UNION_OUTPUT, + (), +) + +HTTP_PAYLOAD_WITH_XML_NAME_INPUT = ( + 18, + n1, + _HPWXNI, + {_sSI: _aHPWXNIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAME, 16),), +) + +HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT = ( + 18, + n1, + _HPWXNO, + {_sSI: _aHPWXNIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAME, 16),), +) + +HTTP_PAYLOAD_WITH_XML_NAME = ( + 23, + n1, + _HPWXN, + {_s: MappingProxyType({"uri": "/HttpPayloadWithXmlName", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_XML_NAME_INPUT, + HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT, + (), +) + +PAYLOAD_WITH_XML_NAMESPACE = ( + 18, + n1, + _PWXNa, + {_sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_n,), + ((3, 0),), +) + +HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT = ( + 18, + n1, + _HPWXNIt, + {_sSI: _aHPWXNIOw}, + (_ne,), + ((PAYLOAD_WITH_XML_NAMESPACE, 16),), +) + +HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT = ( + 18, + n1, + _HPWXNOt, + {_sSI: _aHPWXNIOw}, + (_ne,), + ((PAYLOAD_WITH_XML_NAMESPACE, 16),), +) + +HTTP_PAYLOAD_WITH_XML_NAMESPACE = ( + 23, + n1, + _HPWXNt, + {_s: MappingProxyType({"uri": "/HttpPayloadWithXmlNamespace", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT, + HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT, + (), +) + +PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = ( + 18, + n1, + _PWXNAP, + {_sNm: MappingProxyType({"uri": "http://foo.com", "prefix": "baz"})}, + (_n,), + ((3, 0),), +) + +HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT = ( + 18, + n1, + _HPWXNAPI, + {_sSI: _aHPWXNAPIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, 16),), +) + +HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT = ( + 18, + n1, + _HPWXNAPO, + {_sSI: _aHPWXNAPIO}, + (_ne,), + ((PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, 16),), +) + +HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = ( + 23, + n1, + _HPWXNAP, + { + _s: MappingProxyType( + {"uri": "/HttpPayloadWithXmlNamespaceAndPrefix", "method": "PUT"} + ) + }, + HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT, + HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT, + (), +) + +HTTP_PREFIX_HEADERS_INPUT = ( + 18, + n1, + _HPHI, + {_sSI: _aHPHIO}, + (_f, _fM), + ((3, {_sH: _xf}), (FOO_PREFIX_HEADERS, {_sPH: _xf_})), +) + +HTTP_PREFIX_HEADERS_OUTPUT = ( + 18, + n1, + _HPHO, + {_sSI: _aHPHIO}, + (_f, _fM), + ((3, {_sH: _xf}), (FOO_PREFIX_HEADERS, {_sPH: _xf_})), +) + +HTTP_PREFIX_HEADERS = ( + 23, + n1, + _HPH, + {_s: MappingProxyType({"uri": "/HttpPrefixHeaders", "method": "GET"})}, + HTTP_PREFIX_HEADERS_INPUT, + HTTP_PREFIX_HEADERS_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT = ( + 18, + n1, + _HRWFLI, + 0, + (_fl, _do), + ((9, 9), (10, 9)), +) + +HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT = (18, n1, _HRWFLO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_FLOAT_LABELS = ( + 23, + n1, + _HRWFL, + { + _s: MappingProxyType( + {"method": "GET", "uri": "/FloatHttpLabels/{float}/{double}"} + ) + }, + HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, + HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT = ( + 18, + n1, + _HRWGLIPI, + 0, + (_f, _b), + ((3, 9), (3, 9)), +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT = (18, n1, _HRWGLIPO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = ( + 23, + n1, + _HRWGLIP, + { + _s: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}", + } + ) + }, + HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, + HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_LABELS_INPUT = ( + 18, + n1, + _HRWLI, + 0, + (_st, _sh, _i, _lo, _fl, _do, _bo, _ti), + ((3, 9), (6, 9), (7, 9), (8, 9), (9, 9), (10, 9), (2, 9), (4, 9)), +) + +HTTP_REQUEST_WITH_LABELS_OUTPUT = (18, n1, _HRWLO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_LABELS = ( + 23, + n1, + _HRWL, + { + _s: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}", + } + ) + }, + HTTP_REQUEST_WITH_LABELS_INPUT, + HTTP_REQUEST_WITH_LABELS_OUTPUT, + (), +) + +EPOCH_SECONDS = (4, n0, _ES, {_sF: _es}) + +HTTP_DATE = (4, n0, _HD, {_sF: _hd}) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT = ( + 18, + n1, + _HRWLATFI, + 0, + (_mES, _mHD, _mDT, _dF, _tES, _tHD, _tDT), + ( + (4, {_sF: _es, _smi: None, _sL: None}), + (4, {_sF: _hd, _smi: None, _sL: None}), + (4, {_sF: _dt, _smi: None, _sL: None}), + (4, 9), + (EPOCH_SECONDS, 9), + (HTTP_DATE, 9), + (DATE_TIME, 9), + ), ) -HTTP_PREFIX_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPrefixHeadersInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPrefixHeadersInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-foo")], - }, - "fooMap": { - "target": FOO_PREFIX_HEADERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="x-foo-") - ], - }, - }, +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT = (18, n1, _HRWLATFO, {_sSI: _sU}) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = ( + 23, + n1, + _HRWLATF, + { + _s: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}", + } + ) + }, + HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, + HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, + (), +) + +HTTP_RESPONSE_CODE_INPUT = (18, n1, _HRCI, {_sSI: _sU}) + +HTTP_RESPONSE_CODE_OUTPUT = (18, n1, _HRCO, 0, (_St,), ((7, 128),)) + +HTTP_RESPONSE_CODE = ( + 23, + n1, + _HRC, + {_s: MappingProxyType({"uri": "/HttpResponseCode", "method": "PUT"})}, + HTTP_RESPONSE_CODE_INPUT, + HTTP_RESPONSE_CODE_OUTPUT, + (), +) + +HTTP_STRING_PAYLOAD_INPUT = (18, n1, _HSPI, {_sSI: _aSPI}, (_p,), ((3, 16),)) + +HTTP_STRING_PAYLOAD_OUTPUT = (18, n1, _HSPO, {_sSI: _aSPI}, (_p,), ((3, 16),)) + +HTTP_STRING_PAYLOAD = ( + 23, + n1, + _HSP, + {_s: MappingProxyType({"uri": "/StringPayload", "method": "POST"})}, + HTTP_STRING_PAYLOAD_INPUT, + HTTP_STRING_PAYLOAD_OUTPUT, + (), +) + +IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT = (18, n1, _IQPIRI, {_sSI: _sU}) + +IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT = (18, n1, _IQPIRO, 0, (_b,), ((3, {_sQ: _b}),)) + +IGNORE_QUERY_PARAMS_IN_RESPONSE = ( + 23, + n1, + _IQPIR, + {_s: MappingProxyType({"uri": "/IgnoreQueryParamsInResponse", "method": "GET"})}, + IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, + IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, + (), +) + +INPUT_AND_OUTPUT_WITH_HEADERS_INPUT = ( + 18, + n1, + _IAOWHI, + {_sSI: _aIAOWHIO}, + ( + _hS, + _hB, + _hSe, + _hI, + _hL, + _hF, + _hD, + _hTB, + _hFB, + _hSL, + _hSS, + _hIL, + _hBL, + _hTL, + _hE, + _hEL, + ), + ( + (3, {_sH: _XS}), + (5, {_sH: _XB}), + (6, {_sH: _XS_}), + (7, {_sH: _XI}), + (8, {_sH: _XL}), + (9, {_sH: _XF_}), + (10, {_sH: _XD}), + (2, {_sH: _XB_}), + (2, {_sH: _XB__}), + (STRING_LIST, {_sH: _XS__}), + (STRING_SET, {_sH: _XS___}), + (INTEGER_LIST, {_sH: _XI_}), + (BOOLEAN_LIST, {_sH: _XB___}), + (TIMESTAMP_LIST, {_sH: _XT}), + (FOO_ENUM, {_sH: _XE}), + (FOO_ENUM_LIST, {_sH: _XE_}), + ), ) -HTTP_PREFIX_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpPrefixHeadersOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#HttpPrefixHeadersInputOutput", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="x-foo")], - }, - "fooMap": { - "target": FOO_PREFIX_HEADERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpPrefixHeaders"), value="x-foo-") - ], - }, - }, +INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT = ( + 18, + n1, + _IAOWHO, + {_sSI: _aIAOWHIO}, + ( + _hS, + _hB, + _hSe, + _hI, + _hL, + _hF, + _hD, + _hTB, + _hFB, + _hSL, + _hSS, + _hIL, + _hBL, + _hTL, + _hE, + _hEL, + ), + ( + (3, {_sH: _XS}), + (5, {_sH: _XB}), + (6, {_sH: _XS_}), + (7, {_sH: _XI}), + (8, {_sH: _XL}), + (9, {_sH: _XF_}), + (10, {_sH: _XD}), + (2, {_sH: _XB_}), + (2, {_sH: _XB__}), + (STRING_LIST, {_sH: _XS__}), + (STRING_SET, {_sH: _XS___}), + (INTEGER_LIST, {_sH: _XI_}), + (BOOLEAN_LIST, {_sH: _XB___}), + (TIMESTAMP_LIST, {_sH: _XT}), + (FOO_ENUM, {_sH: _XE}), + (FOO_ENUM_LIST, {_sH: _XE_}), + ), ) -HTTP_PREFIX_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpPrefixHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpPrefixHeaders", "method": "GET"}), - ) - ], -) - -HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithFloatLabelsInput"), - members={ - "float": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "double": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - }, +INPUT_AND_OUTPUT_WITH_HEADERS = ( + 23, + n1, + _IAOWH, + {_s: MappingProxyType({"uri": "/InputAndOutputWithHeaders", "method": "POST"})}, + INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, + INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, + (), ) - -HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithFloatLabelsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_FLOAT_LABELS = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithFloatLabels"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "GET", "uri": "/FloatHttpLabels/{float}/{double}"} - ), - ) - ], -) - -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithGreedyLabelInPathInput"), - members={ - "foo": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "baz": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, + +LIST_WITH_MEMBER_NAMESPACE = ( + 16, + n1, + _LWMN, + {_sNm: MappingProxyType({"uri": "https://xml-list.example.com"})}, + (_m,), + ((3, {_sNm: MappingProxyType({"uri": "https://xml-member.example.com"})}),), +) + +LIST_WITH_NAMESPACE = ( + 16, + n1, + _LWN, + {_sNm: MappingProxyType({"uri": "https://xml-list.example.com"})}, + (_m,), + ((3, 0),), +) + +NESTED_MAP = (17, n1, _NM, 0, (_k, _v), ((3, 0), (FOO_ENUM_MAP, 0))) + +NESTED_XML_MAPS_INPUT = ( + 18, + n1, + _NXMI, + {_sSI: _aNXMR}, + (_nM, _fNM), + ((NESTED_MAP, 0), (NESTED_MAP, {_sFm: None})), +) + +NESTED_XML_MAPS_OUTPUT = ( + 18, + n1, + _NXMO, + {_sSI: _aNXMRw}, + (_nM, _fNM), + ((NESTED_MAP, 0), (NESTED_MAP, {_sFm: None})), +) + +NESTED_XML_MAPS = ( + 23, + n1, + _NXM, + {_s: MappingProxyType({"uri": "/NestedXmlMaps", "method": "POST"})}, + NESTED_XML_MAPS_INPUT, + NESTED_XML_MAPS_OUTPUT, + (), +) + +NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP = ( + 17, + n1, + _NXMWXNIM, + 0, + (_k, _v), + ((3, {_sN: _IK}), (3, {_sN: _IV})), +) + +NESTED_XML_MAP_WITH_XML_NAME_MAP = ( + 17, + n1, + _NXMWXNM, + 0, + (_k, _v), + ((3, {_sN: _OK}), (NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP, 0)), +) + +NESTED_XML_MAP_WITH_XML_NAME_INPUT = ( + 18, + n1, + _NXMWXNI, + {_sSI: _aNXMWXNR}, + (_nXMWXNM,), + ((NESTED_XML_MAP_WITH_XML_NAME_MAP, 0),), +) + +NESTED_XML_MAP_WITH_XML_NAME_OUTPUT = ( + 18, + n1, + _NXMWXNO, + {_sSI: _aNXMWXNRw}, + (_nXMWXNM,), + ((NESTED_XML_MAP_WITH_XML_NAME_MAP, 0),), +) + +NESTED_XML_MAP_WITH_XML_NAME = ( + 23, + n1, + _NXMWXN, + {_s: MappingProxyType({"uri": "/NestedXmlMapWithXmlName", "method": "POST"})}, + NESTED_XML_MAP_WITH_XML_NAME_INPUT, + NESTED_XML_MAP_WITH_XML_NAME_OUTPUT, + (), +) + +NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n1, _NIANOI, {_sSI: _sU}) + +NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n1, _NIANOO, {_sSI: _sU}) + +NO_INPUT_AND_NO_OUTPUT = ( + 23, + n1, + _NIANO, + {_s: MappingProxyType({"uri": "/NoInputAndNoOutput", "method": "POST"})}, + NO_INPUT_AND_NO_OUTPUT_INPUT, + NO_INPUT_AND_NO_OUTPUT_OUTPUT, + (), +) + +NO_INPUT_AND_OUTPUT_INPUT = (18, n1, _NIAOI, {_sSI: _sU}) + +NO_INPUT_AND_OUTPUT_OUTPUT = (18, n1, _NIAOO, 0) + +NO_INPUT_AND_OUTPUT = ( + 23, + n1, + _NIAO, + {_s: MappingProxyType({"uri": "/NoInputAndOutputOutput", "method": "POST"})}, + NO_INPUT_AND_OUTPUT_INPUT, + NO_INPUT_AND_OUTPUT_OUTPUT, + (), +) + +NULL_AND_EMPTY_HEADERS_CLIENT_INPUT = ( + 18, + n1, + _NAEHCI, + {_sSI: _aNAEHIO}, + (_a, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT = ( + 18, + n1, + _NAEHCO, + {_sSI: _aNAEHIO}, + (_a, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_CLIENT = ( + 23, + n1, + _NAEHC, + {_s: MappingProxyType({"uri": "/NullAndEmptyHeadersClient", "method": "GET"})}, + NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, + NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, + (), +) + +NULL_AND_EMPTY_HEADERS_SERVER_INPUT = ( + 18, + n1, + _NAEHSI, + {_sSI: _aNAEHIO}, + (_a, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT = ( + 18, + n1, + _NAEHSO, + {_sSI: _aNAEHIO}, + (_a, _b_, _c_), + ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), +) + +NULL_AND_EMPTY_HEADERS_SERVER = ( + 23, + n1, + _NAEHS, + {_s: MappingProxyType({"uri": "/NullAndEmptyHeadersServer", "method": "GET"})}, + NULL_AND_EMPTY_HEADERS_SERVER_INPUT, + NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, + (), +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT = ( + 18, + n1, + _ONSESI, + 0, + (_nV, _eS), + ((3, {_sQ: _Nu}), (3, {_sQ: _Em})), +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT = (18, n1, _ONSESO, {_sSI: _sU}) + +OMITS_NULL_SERIALIZES_EMPTY_STRING = ( + 23, + n1, + _ONSES, + {_s: MappingProxyType({"uri": "/OmitsNullSerializesEmptyString", "method": "GET"})}, + OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, + OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, + (), +) + +PUT_WITH_CONTENT_ENCODING_INPUT = ( + 18, + n1, + _PWCEI, + 0, + (_e, _da), + ((3, {_sH: _CE_}), (3, 0)), +) + +PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n1, _PWCEO, {_sSI: _sU}) + +PUT_WITH_CONTENT_ENCODING = ( + 23, + n1, + _PWCE, + { + _sC: MappingProxyType({"encodings": ("gzip",)}), + _s: MappingProxyType( + {"method": "POST", "uri": "/requestcompression/putcontentwithencoding"} + ), }, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), +) + +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = ( + 18, + n1, + _QITAFI, + 0, + (_to,), + ((3, {_sQ: _to, _sTm: None}),), +) + +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n1, _QITAFO, {_sSI: _sU}) + +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( + 23, + n1, + _QITAF, + {_s: MappingProxyType({"uri": "/QueryIdempotencyTokenAutoFill", "method": "POST"})}, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + (), +) + +STRING_LIST_MAP = (17, n0, _SLM, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) + +QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT = ( + 18, + n1, + _QPASLMI, + 0, + (_q, _f), + ((3, {_sQ: _co}), (STRING_LIST_MAP, 1024)), +) + +QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT = (18, n1, _QPASLMO, {_sSI: _sU}) + +QUERY_PARAMS_AS_STRING_LIST_MAP = ( + 23, + n1, + _QPASLM, + {_s: MappingProxyType({"uri": "/StringListMap", "method": "POST"})}, + QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, + QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, + (), +) + +QUERY_PRECEDENCE_INPUT = ( + 18, + n1, + _QPI, + 0, + (_f, _b), + ((3, {_sQ: _ba}), (STRING_MAP, 1024)), +) + +QUERY_PRECEDENCE_OUTPUT = (18, n1, _QPO, {_sSI: _sU}) + +QUERY_PRECEDENCE = ( + 23, + n1, + _QP, + {_s: MappingProxyType({"uri": "/Precedence", "method": "POST"})}, + QUERY_PRECEDENCE_INPUT, + QUERY_PRECEDENCE_OUTPUT, + (), +) + +RENAMED_LIST_MEMBERS = (16, n1, _RLM, 0, (_m,), ((3, {_sN: _it}),)) + +SIMPLE_SCALAR_PROPERTIES_INPUT = ( + 18, + n1, + _SSPI, + {_sSI: _aSSPR}, + (_f, _sV, _tBV, _fBV, _bV, _sVh, _iV, _lV, _fV, _dV), + ( + (3, {_sH: _XF}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_sN: _DD}), + ), ) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithGreedyLabelInPathOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithGreedyLabelInPath"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "method": "GET", - "uri": "/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}", - } - ), - ) - ], -) - -HTTP_REQUEST_WITH_LABELS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithLabelsInput"), - members={ - "string": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "short": { - "target": SHORT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "integer": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "long": { - "target": LONG, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "float": { - "target": FLOAT, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "double": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "boolean": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "timestamp": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - }, +SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( + 18, + n1, + _SSPO, + {_sSI: _aSSPRw}, + (_f, _sV, _tBV, _fBV, _bV, _sVh, _iV, _lV, _fV, _dV), + ( + (3, {_sH: _XF}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_sN: _DD}), + ), ) -HTTP_REQUEST_WITH_LABELS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithLabelsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_LABELS = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithLabels"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "method": "GET", - "uri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}", - } - ), - ) - ], +SIMPLE_SCALAR_PROPERTIES = ( + 23, + n1, + _SSP, + {_s: MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"})}, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), +) + +TIMESTAMP_FORMAT_HEADERS_INPUT = ( + 18, + n1, + _TFHI, + {_sSI: _aTFHIO}, + (_mES, _mHD, _mDT, _dF, _tES, _tHD, _tDT), + ( + (4, {_sF: _es, _sH: _Xm}), + (4, {_sF: _hd, _sH: _Xm_}), + (4, {_sF: _dt, _sH: _Xm__}), + (4, {_sH: _Xd}), + (EPOCH_SECONDS, {_sH: _Xt}), + (HTTP_DATE, {_sH: _Xt_}), + (DATE_TIME, {_sH: _Xt__}), + ), ) -EPOCH_SECONDS = Schema( - id=ShapeID("aws.protocoltests.shared#EpochSeconds"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds")], +TIMESTAMP_FORMAT_HEADERS_OUTPUT = ( + 18, + n1, + _TFHO, + {_sSI: _aTFHIO}, + (_mES, _mHD, _mDT, _dF, _tES, _tHD, _tDT), + ( + (4, {_sF: _es, _sH: _Xm}), + (4, {_sF: _hd, _sH: _Xm_}), + (4, {_sF: _dt, _sH: _Xm__}), + (4, {_sH: _Xd}), + (EPOCH_SECONDS, {_sH: _Xt}), + (HTTP_DATE, {_sH: _Xt_}), + (DATE_TIME, {_sH: _Xt__}), + ), ) -HTTP_DATE = Schema( - id=ShapeID("aws.protocoltests.shared#HttpDate"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date")], +TIMESTAMP_FORMAT_HEADERS = ( + 23, + n1, + _TFH, + {_s: MappingProxyType({"uri": "/TimestampFormatHeaders", "method": "POST"})}, + TIMESTAMP_FORMAT_HEADERS_INPUT, + TIMESTAMP_FORMAT_HEADERS_OUTPUT, + (), +) + +XML_ATTRIBUTES_INPUT = ( + 18, + n1, + _XAI, + {_sSI: _aXAR}, + (_f, _at), + ((3, 0), (3, {_sN: _te, _sA: None})), +) + +XML_ATTRIBUTES_OUTPUT = ( + 18, + n1, + _XAO, + {_sSI: _aXARw}, + (_f, _at), + ((3, 0), (3, {_sN: _te, _sA: None})), +) + +XML_ATTRIBUTES = ( + 23, + n1, + _XAm, + {_s: MappingProxyType({"uri": "/XmlAttributes", "method": "PUT"})}, + XML_ATTRIBUTES_INPUT, + XML_ATTRIBUTES_OUTPUT, + (), +) + +XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST = ( + 18, + n1, + _XAIMPR, + 0, + (_f, _at, _b), + ((3, 0), (3, {_sN: _te, _sA: None}), (3, 0)), +) + +XML_ATTRIBUTES_IN_MIDDLE_INPUT = ( + 18, + n1, + _XAIMI, + {_sSI: _aXAIMR}, + (_p,), + ((XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST, 16),), +) + +XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE = ( + 18, + n1, + _XAIMPRm, + 0, + (_f, _at, _b), + ((3, 0), (3, {_sN: _te, _sA: None}), (3, 0)), ) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restxml#HttpRequestWithLabelsAndTimestampFormatInput" +XML_ATTRIBUTES_IN_MIDDLE_OUTPUT = ( + 18, + n1, + _XAIMO, + {_sSI: _aXAIMRw}, + (_p,), + ((XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE, 16),), +) + +XML_ATTRIBUTES_IN_MIDDLE = ( + 23, + n1, + _XAIM, + {_s: MappingProxyType({"uri": "/XmlAttributesInMiddle", "method": "PUT"})}, + XML_ATTRIBUTES_IN_MIDDLE_INPUT, + XML_ATTRIBUTES_IN_MIDDLE_OUTPUT, + (), +) + +XML_ATTRIBUTES_PAYLOAD_REQUEST = ( + 18, + n1, + _XAPR, + 0, + (_f, _at), + ((3, 0), (3, {_sN: _te, _sA: None})), +) + +XML_ATTRIBUTES_ON_PAYLOAD_INPUT = ( + 18, + n1, + _XAOPI, + {_sSI: _aXAOPR}, + (_p,), + ((XML_ATTRIBUTES_PAYLOAD_REQUEST, 16),), +) + +XML_ATTRIBUTES_PAYLOAD_RESPONSE = ( + 18, + n1, + _XAPRm, + 0, + (_f, _at), + ((3, 0), (3, {_sN: _te, _sA: None})), +) + +XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT = ( + 18, + n1, + _XAOPO, + {_sSI: _aXAOPRw}, + (_p,), + ((XML_ATTRIBUTES_PAYLOAD_RESPONSE, 16),), +) + +XML_ATTRIBUTES_ON_PAYLOAD = ( + 23, + n1, + _XAOP, + {_s: MappingProxyType({"uri": "/XmlAttributesOnPayload", "method": "PUT"})}, + XML_ATTRIBUTES_ON_PAYLOAD_INPUT, + XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT, + (), +) + +XML_BLOBS_INPUT = (18, n1, _XBI, {_sSI: _aXBR}, (_da,), ((1, 0),)) + +XML_BLOBS_OUTPUT = (18, n1, _XBO, {_sSI: _aXBRw}, (_da,), ((1, 0),)) + +XML_BLOBS = ( + 23, + n1, + _XBm, + {_s: MappingProxyType({"uri": "/XmlBlobs", "method": "POST"})}, + XML_BLOBS_INPUT, + XML_BLOBS_OUTPUT, + (), +) + +XML_EMPTY_BLOBS_INPUT = (18, n1, _XEBI, {_sSI: _aXEBR}, (_da,), ((1, 0),)) + +XML_EMPTY_BLOBS_OUTPUT = (18, n1, _XEBO, {_sSI: _aXEBRw}, (_da,), ((1, 0),)) + +XML_EMPTY_BLOBS = ( + 23, + n1, + _XEB, + {_s: MappingProxyType({"uri": "/XmlEmptyBlobs", "method": "POST"})}, + XML_EMPTY_BLOBS_INPUT, + XML_EMPTY_BLOBS_OUTPUT, + (), +) + +STRUCTURE_LIST_MEMBER = (18, n1, _SLMt, 0, (_a, _b_), ((3, {_sN: _v}), (3, {_sN: _o}))) + +STRUCTURE_LIST = (16, n1, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, {_sN: _it}),)) + +NESTED_STRING_LIST = (16, n0, _NSL, 0, (_m,), ((STRING_LIST, 0),)) + +XML_EMPTY_LISTS_INPUT = ( + 18, + n1, + _XELI, + {_sSI: _aXELR}, + ( + _sLt, + _sS, + _iL, + _bL, + _tL, + _eL, + _iEL, + _nSL, + _rLM, + _fL, + _fLl, + _fLWMN, + _fLWN, + _sLtr, + _fSL, ), - members={ - "memberEpochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "memberHttpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "memberDateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "defaultFormat": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "targetEpochSeconds": { - "target": EPOCH_SECONDS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "targetHttpDate": { - "target": HTTP_DATE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - "targetDateTime": { - "target": DATE_TIME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#required")), - Trait.new(id=ShapeID("smithy.api#httpLabel")), - ], - }, - }, -) - -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT = Schema.collection( - id=ShapeID( - "aws.protocoltests.restxml#HttpRequestWithLabelsAndTimestampFormatOutput" + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + (STRUCTURE_LIST, {_sFm: None}), ), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpRequestWithLabelsAndTimestampFormat"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - { - "method": "GET", - "uri": "/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}", - } - ), - ) - ], -) - -HTTP_RESPONSE_CODE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpResponseCodeInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], ) -HTTP_RESPONSE_CODE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpResponseCodeOutput"), - members={ - "Status": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#httpResponseCode"))], - } - }, +XML_EMPTY_LISTS_OUTPUT = ( + 18, + n1, + _XELO, + {_sSI: _aXELRw}, + ( + _sLt, + _sS, + _iL, + _bL, + _tL, + _eL, + _iEL, + _nSL, + _rLM, + _fL, + _fLl, + _fLWMN, + _fLWN, + _sLtr, + _fSL, + ), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + (STRUCTURE_LIST, {_sFm: None}), + ), ) -HTTP_RESPONSE_CODE = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpResponseCode"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/HttpResponseCode", "method": "PUT"}), - ) - ], +XML_EMPTY_LISTS = ( + 23, + n1, + _XEL, + {_s: MappingProxyType({"uri": "/XmlEmptyLists", "method": "PUT"})}, + XML_EMPTY_LISTS_INPUT, + XML_EMPTY_LISTS_OUTPUT, + (), +) + +GREETING_STRUCT = (18, n0, _GS, 0, (_hi,), ((3, 0),)) + +XML_MAPS_INPUT_OUTPUT_MAP = ( + 17, + n1, + _XMIOM, + 0, + (_k, _v), + ((3, 0), (GREETING_STRUCT, 0)), +) + +XML_EMPTY_MAPS_INPUT = ( + 18, + n1, + _XEMI, + {_sSI: _aXEMR}, + (_mM,), + ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), +) + +XML_EMPTY_MAPS_OUTPUT = ( + 18, + n1, + _XEMO, + {_sSI: _aXEMRw}, + (_mM,), + ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), +) + +XML_EMPTY_MAPS = ( + 23, + n1, + _XEM, + {_s: MappingProxyType({"uri": "/XmlEmptyMaps", "method": "POST"})}, + XML_EMPTY_MAPS_INPUT, + XML_EMPTY_MAPS_OUTPUT, + (), +) + +XML_EMPTY_STRINGS_INPUT = (18, n1, _XESI, {_sSI: _aXESR}, (_eS,), ((3, 0),)) + +XML_EMPTY_STRINGS_OUTPUT = (18, n1, _XESO, {_sSI: _aXESRw}, (_eS,), ((3, 0),)) + +XML_EMPTY_STRINGS = ( + 23, + n1, + _XES, + {_s: MappingProxyType({"uri": "/XmlEmptyStrings", "method": "PUT"})}, + XML_EMPTY_STRINGS_INPUT, + XML_EMPTY_STRINGS_OUTPUT, + (), +) + +FOO_ENUM_SET = (16, n0, _FES, 0, (_m,), ((FOO_ENUM, 0),)) + +XML_ENUMS_INPUT = ( + 18, + n1, + _XEI, + {_sSI: _aXER}, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -HTTP_STRING_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpStringPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#StringPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +XML_ENUMS_OUTPUT = ( + 18, + n1, + _XEO, + {_sSI: _aXERw}, + (_fE, _fEo, _fEoo, _fEL, _fES, _fEM), + ( + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM, 0), + (FOO_ENUM_LIST, 0), + (FOO_ENUM_SET, 0), + (FOO_ENUM_MAP, 0), + ), ) -HTTP_STRING_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#HttpStringPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#StringPayloadInput", - ) - ], - members={ - "payload": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, +XML_ENUMS = ( + 23, + n1, + _XEm, + {_s: MappingProxyType({"uri": "/XmlEnums", "method": "PUT"})}, + XML_ENUMS_INPUT, + XML_ENUMS_OUTPUT, + (), +) + +INTEGER_ENUM_MAP = (17, n0, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) + +INTEGER_ENUM_SET = (16, n0, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) + +XML_INT_ENUMS_INPUT = ( + 18, + n1, + _XIEI, + {_sSI: _aXIER}, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), ) -HTTP_STRING_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restxml#HttpStringPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/StringPayload", "method": "POST"}), - ) - ], +XML_INT_ENUMS_OUTPUT = ( + 18, + n1, + _XIEO, + {_sSI: _aXIERw}, + (_iE, _iEn, _iEnt, _iEL, _iES, _iEM), + ( + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM, 0), + (INTEGER_ENUM_LIST, 0), + (INTEGER_ENUM_SET, 0), + (INTEGER_ENUM_MAP, 0), + ), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#IgnoreQueryParamsInResponseInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], +XML_INT_ENUMS = ( + 23, + n1, + _XIE, + {_s: MappingProxyType({"uri": "/XmlIntEnums", "method": "PUT"})}, + XML_INT_ENUMS_INPUT, + XML_INT_ENUMS_OUTPUT, + (), +) + +XML_LISTS_INPUT = ( + 18, + n1, + _XLI, + {_sSI: _aXLR}, + ( + _sLt, + _sS, + _iL, + _bL, + _tL, + _eL, + _iEL, + _nSL, + _rLM, + _fL, + _fLl, + _fLWMN, + _fLWN, + _sLtr, + _fSL, + ), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + (STRUCTURE_LIST, {_sFm: None}), + ), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#IgnoreQueryParamsInResponseOutput"), - members={ - "baz": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="baz")], - } - }, +XML_LISTS_OUTPUT = ( + 18, + n1, + _XLO, + {_sSI: _aXLRw}, + ( + _sLt, + _sS, + _iL, + _bL, + _tL, + _eL, + _iEL, + _nSL, + _rLM, + _fL, + _fLl, + _fLWMN, + _fLWN, + _sLtr, + _fSL, + ), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (RENAMED_LIST_MEMBERS, {_sN: _r}), + (RENAMED_LIST_MEMBERS, {_sFm: None}), + (RENAMED_LIST_MEMBERS, {_sN: _cN, _sFm: None}), + (LIST_WITH_MEMBER_NAMESPACE, {_sFm: None}), + (LIST_WITH_NAMESPACE, {_sFm: None}), + (STRUCTURE_LIST, {_sN: _mSL}), + (STRUCTURE_LIST, {_sFm: None}), + ), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE = Schema( - id=ShapeID("aws.protocoltests.restxml#IgnoreQueryParamsInResponse"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/IgnoreQueryParamsInResponse", "method": "GET"} - ), - ) - ], +XML_LISTS = ( + 23, + n1, + _XLm, + {_s: MappingProxyType({"uri": "/XmlLists", "method": "PUT"})}, + XML_LISTS_INPUT, + XML_LISTS_OUTPUT, + (), +) + +XML_MAPS_INPUT = ( + 18, + n1, + _XMI, + {_sSI: _aXMR}, + (_mM,), + ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), +) + +XML_MAPS_OUTPUT = ( + 18, + n1, + _XMO, + {_sSI: _aXMRw}, + (_mM,), + ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), +) + +XML_MAPS = ( + 23, + n1, + _XM, + {_s: MappingProxyType({"uri": "/XmlMaps", "method": "POST"})}, + XML_MAPS_INPUT, + XML_MAPS_OUTPUT, + (), +) + +XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP = ( + 17, + n1, + _XMXNIOM, + 0, + (_k, _v), + ((3, {_sN: _At}), (GREETING_STRUCT, {_sN: _Se})), +) + +XML_MAPS_XML_NAME_INPUT = ( + 18, + n1, + _XMXNI, + {_sSI: _aXMXNR}, + (_mM,), + ((XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP, 0),), +) + +XML_MAPS_XML_NAME_OUTPUT = ( + 18, + n1, + _XMXNO, + {_sSI: _aXMXNRw}, + (_mM,), + ((XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP, 0),), +) + +XML_MAPS_XML_NAME = ( + 23, + n1, + _XMXN, + {_s: MappingProxyType({"uri": "/XmlMapsXmlName", "method": "POST"})}, + XML_MAPS_XML_NAME_INPUT, + XML_MAPS_XML_NAME_OUTPUT, + (), +) + +XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP = ( + 17, + n1, + _XMWXNIOM, + 0, + (_k, _v), + ( + (3, {_sN: _K, _sNm: MappingProxyType({"uri": "https://the-key.example.com"})}), + ( + 3, + {_sN: _V, _sNm: MappingProxyType({"uri": "https://the-value.example.com"})}, + ), + ), ) -INPUT_AND_OUTPUT_WITH_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#InputAndOutputWithHeadersInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#InputAndOutputWithHeadersIO", - ) - ], - members={ - "headerString": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-String") - ], - }, - "headerByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Byte")], - }, - "headerShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Short")], - }, - "headerInteger": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Integer") - ], - }, - "headerLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Long")], - }, - "headerFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Float")], - }, - "headerDouble": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Double") - ], - }, - "headerTrueBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean1") - ], - }, - "headerFalseBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean2") - ], - }, - "headerStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringList") - ], - }, - "headerStringSet": { - "target": STRING_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringSet") - ], - }, - "headerIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-IntegerList") - ], - }, - "headerBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-BooleanList") - ], - }, - "headerTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-TimestampList") - ], - }, - "headerEnum": { - "target": FOO_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Enum")], - }, - "headerEnumList": { - "target": FOO_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-EnumList") - ], - }, - }, +XML_MAP_WITH_XML_NAMESPACE_INPUT = ( + 18, + n1, + _XMWXNI, + {_sSI: _aXMWXNR}, + (_mM,), + ( + ( + XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP, + { + _sN: _KVP, + _sNm: MappingProxyType({"uri": "https://the-member.example.com"}), + }, + ), + ), ) -INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#InputAndOutputWithHeadersOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#InputAndOutputWithHeadersIO", - ) - ], - members={ - "headerString": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-String") - ], - }, - "headerByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Byte")], - }, - "headerShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Short")], - }, - "headerInteger": { - "target": INTEGER, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Integer") - ], - }, - "headerLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Long")], - }, - "headerFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Float")], - }, - "headerDouble": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Double") - ], - }, - "headerTrueBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean1") - ], - }, - "headerFalseBool": { - "target": BOOLEAN, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Boolean2") - ], - }, - "headerStringList": { - "target": STRING_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringList") - ], - }, - "headerStringSet": { - "target": STRING_SET, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-StringSet") - ], - }, - "headerIntegerList": { - "target": INTEGER_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-IntegerList") - ], - }, - "headerBooleanList": { - "target": BOOLEAN_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-BooleanList") - ], - }, - "headerTimestampList": { - "target": TIMESTAMP_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-TimestampList") - ], - }, - "headerEnum": { - "target": FOO_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Enum")], - }, - "headerEnumList": { - "target": FOO_ENUM_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-EnumList") - ], - }, - }, +XML_MAP_WITH_XML_NAMESPACE_OUTPUT = ( + 18, + n1, + _XMWXNO, + {_sSI: _aXMWXNRw}, + (_mM,), + ( + ( + XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP, + { + _sN: _KVP, + _sNm: MappingProxyType({"uri": "https://the-member.example.com"}), + }, + ), + ), ) -INPUT_AND_OUTPUT_WITH_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restxml#InputAndOutputWithHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/InputAndOutputWithHeaders", "method": "POST"} - ), - ) - ], +XML_MAP_WITH_XML_NAMESPACE = ( + 23, + n1, + _XMWXN, + {_s: MappingProxyType({"uri": "/XmlMapWithXmlNamespace", "method": "POST"})}, + XML_MAP_WITH_XML_NAMESPACE_INPUT, + XML_MAP_WITH_XML_NAMESPACE_OUTPUT, + (), +) + +XML_NAMESPACED_LIST = ( + 16, + n1, + _XNL, + 0, + (_m,), + ((3, {_sNm: MappingProxyType({"uri": "http://bux.com"})}),), +) + +XML_NAMESPACE_NESTED = ( + 18, + n1, + _XNN, + {_sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_f, _va), + ( + (3, {_sNm: MappingProxyType({"uri": "http://baz.com", "prefix": "baz"})}), + (XML_NAMESPACED_LIST, {_sNm: MappingProxyType({"uri": "http://qux.com"})}), + ), ) -LIST_WITH_MEMBER_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ListWithMemberNamespace"), - shape_type=ShapeType.LIST, - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-list.example.com"}), - ) - ], - members={ - "member": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-member.example.com"}), - ) - ], - } - }, +XML_NAMESPACES_INPUT = ( + 18, + n1, + _XNI, + {_sSI: _aXNR, _sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_ne,), + ((XML_NAMESPACE_NESTED, 0),), +) + +XML_NAMESPACES_OUTPUT = ( + 18, + n1, + _XNO, + {_sSI: _aXNRw, _sNm: MappingProxyType({"uri": "http://foo.com"})}, + (_ne,), + ((XML_NAMESPACE_NESTED, 0),), +) + +XML_NAMESPACES = ( + 23, + n1, + _XN, + {_s: MappingProxyType({"uri": "/XmlNamespaces", "method": "POST"})}, + XML_NAMESPACES_INPUT, + XML_NAMESPACES_OUTPUT, + (), +) + +XML_TIMESTAMPS_INPUT = ( + 18, + n1, + _XTI, + {_sSI: _aXTR}, + (_no, _dT, _dTOT, _eSp, _eSOT, _hDt, _hDOT), + ( + (4, 0), + (4, {_sF: _dt}), + (DATE_TIME, 0), + (4, {_sF: _es}), + (EPOCH_SECONDS, 0), + (4, {_sF: _hd}), + (HTTP_DATE, 0), + ), ) -LIST_WITH_NAMESPACE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#ListWithNamespace"), - shape_type=ShapeType.LIST, - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://xml-list.example.com"}), - ) - ], - members={"member": {"target": STRING}}, +XML_TIMESTAMPS_OUTPUT = ( + 18, + n1, + _XTO, + {_sSI: _aXTRw}, + (_no, _dT, _dTOT, _eSp, _eSOT, _hDt, _hDOT), + ( + (4, 0), + (4, {_sF: _dt}), + (DATE_TIME, 0), + (4, {_sF: _es}), + (EPOCH_SECONDS, 0), + (4, {_sF: _hd}), + (HTTP_DATE, 0), + ), ) -NESTED_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": FOO_ENUM_MAP}}, +XML_TIMESTAMPS = ( + 23, + n1, + _XTm, + {_s: MappingProxyType({"uri": "/XmlTimestamps", "method": "POST"})}, + XML_TIMESTAMPS_INPUT, + XML_TIMESTAMPS_OUTPUT, + (), +) + +XML_NESTED_UNION_STRUCT = ( + 18, + n1, + _XNUS, + 0, + (_sV, _bVo, _bV, _sVh, _iV, _lV, _fV, _dV), + ((3, 0), (2, 0), (5, 0), (6, 0), (7, 0), (8, 0), (9, 0), (10, 0)), +) + +XML_UNION_SHAPE = ( + 19, + n1, + _XUS, + 0, + (_sV, _bVo, _bV, _sVh, _iV, _lV, _fV, _dV, _uV, _sVt), + ( + (3, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, 0), + (lambda: XML_UNION_SHAPE, 0), + (XML_NESTED_UNION_STRUCT, 0), + ), ) -NESTED_XML_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NestedXmlMapsRequest", - ) - ], - members={ - "nestedMap": {"target": NESTED_MAP}, - "flatNestedMap": { - "target": NESTED_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - }, -) - -NESTED_XML_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NestedXmlMapsResponse", - ) - ], - members={ - "nestedMap": {"target": NESTED_MAP}, - "flatNestedMap": { - "target": NESTED_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - }, -) - -NESTED_XML_MAPS = Schema( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMaps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/NestedXmlMaps", "method": "POST"}), - ) - ], -) - -NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapWithXmlNameInnerMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="InnerKey")], - }, - "value": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="InnerValue")], - }, - }, -) - -NESTED_XML_MAP_WITH_XML_NAME_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapWithXmlNameMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="OuterKey")], - }, - "value": {"target": NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP}, - }, -) - -NESTED_XML_MAP_WITH_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapWithXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NestedXmlMapWithXmlNameRequest", - ) - ], - members={ - "nestedXmlMapWithXmlNameMap": {"target": NESTED_XML_MAP_WITH_XML_NAME_MAP} - }, -) - -NESTED_XML_MAP_WITH_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapWithXmlNameOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NestedXmlMapWithXmlNameResponse", - ) - ], - members={ - "nestedXmlMapWithXmlNameMap": {"target": NESTED_XML_MAP_WITH_XML_NAME_MAP} - }, -) - -NESTED_XML_MAP_WITH_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.restxml#NestedXmlMapWithXmlName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NestedXmlMapWithXmlName", "method": "POST"} - ), - ) - ], -) - -NO_INPUT_AND_NO_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NoInputAndNoOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_NO_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NoInputAndNoOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_NO_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restxml#NoInputAndNoOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/NoInputAndNoOutput", "method": "POST"}), - ) - ], -) - -NO_INPUT_AND_OUTPUT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NoInputAndOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_AND_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NoInputAndOutputOutput") -) - -NO_INPUT_AND_OUTPUT = Schema( - id=ShapeID("aws.protocoltests.restxml#NoInputAndOutput"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NoInputAndOutputOutput", "method": "POST"} - ), - ) - ], -) - -NULL_AND_EMPTY_HEADERS_CLIENT_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NullAndEmptyHeadersClientInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, -) - -NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NullAndEmptyHeadersClientOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, -) - -NULL_AND_EMPTY_HEADERS_CLIENT = Schema( - id=ShapeID("aws.protocoltests.restxml#NullAndEmptyHeadersClient"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NullAndEmptyHeadersClient", "method": "GET"} - ), - ) - ], -) - -NULL_AND_EMPTY_HEADERS_SERVER_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NullAndEmptyHeadersServerInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, -) - -NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#NullAndEmptyHeadersServerOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#NullAndEmptyHeadersIO", - ) - ], - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-A")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-B")], - }, - "c": { - "target": STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-C")], - }, - }, -) - -NULL_AND_EMPTY_HEADERS_SERVER = Schema( - id=ShapeID("aws.protocoltests.restxml#NullAndEmptyHeadersServer"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/NullAndEmptyHeadersServer", "method": "GET"} - ), - ) - ], -) - -OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#OmitsNullSerializesEmptyStringInput"), - members={ - "nullValue": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Null")], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="Empty")], - }, - }, -) - -OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#OmitsNullSerializesEmptyStringOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -OMITS_NULL_SERIALIZES_EMPTY_STRING = Schema( - id=ShapeID("aws.protocoltests.restxml#OmitsNullSerializesEmptyString"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/OmitsNullSerializesEmptyString", "method": "GET"} - ), - ) - ], -) - -PUT_WITH_CONTENT_ENCODING_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#PutWithContentEncodingInput"), - members={ - "encoding": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="Content-Encoding") - ], - }, - "data": {"target": STRING}, - }, -) - -PUT_WITH_CONTENT_ENCODING_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#PutWithContentEncodingOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -PUT_WITH_CONTENT_ENCODING = Schema( - id=ShapeID("aws.protocoltests.restxml#PutWithContentEncoding"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#requestCompression"), - value=MappingProxyType({"encodings": ("gzip",)}), - ), - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"method": "POST", "uri": "/requestcompression/putcontentwithencoding"} - ), - ), - ], -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#QueryIdempotencyTokenAutoFillInput"), - members={ - "token": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#idempotencyToken")), - Trait.new(id=ShapeID("smithy.api#httpQuery"), value="token"), - ], - } - }, -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#QueryIdempotencyTokenAutoFillOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = Schema( - id=ShapeID("aws.protocoltests.restxml#QueryIdempotencyTokenAutoFill"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/QueryIdempotencyTokenAutoFill", "method": "POST"} - ), - ) - ], -) - -STRING_LIST_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#StringListMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING_LIST}}, -) - -QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#QueryParamsAsStringListMapInput"), - members={ - "qux": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="corge")], - }, - "foo": { - "target": STRING_LIST_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - }, - }, -) - -QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#QueryParamsAsStringListMapOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_PARAMS_AS_STRING_LIST_MAP = Schema( - id=ShapeID("aws.protocoltests.restxml#QueryParamsAsStringListMap"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/StringListMap", "method": "POST"}), - ) - ], -) - -QUERY_PRECEDENCE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#QueryPrecedenceInput"), - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQuery"), value="bar")], - }, - "baz": { - "target": STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#httpQueryParams"))], - }, - }, -) - -QUERY_PRECEDENCE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#QueryPrecedenceOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -QUERY_PRECEDENCE = Schema( - id=ShapeID("aws.protocoltests.restxml#QueryPrecedence"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/Precedence", "method": "POST"}), - ) - ], -) - -RENAMED_LIST_MEMBERS = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#RenamedListMembers"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, -) - -SIMPLE_SCALAR_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#SimpleScalarPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#SimpleScalarPropertiesRequest", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "stringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="DoubleDribble") - ], - }, - }, -) - -SIMPLE_SCALAR_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#SimpleScalarPropertiesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#SimpleScalarPropertiesResponse", - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-Foo")], - }, - "stringValue": {"target": STRING}, - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": { - "target": DOUBLE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="DoubleDribble") - ], - }, - }, -) - -SIMPLE_SCALAR_PROPERTIES = Schema( - id=ShapeID("aws.protocoltests.restxml#SimpleScalarProperties"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"}), - ) - ], -) - -TIMESTAMP_FORMAT_HEADERS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#TimestampFormatHeadersInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#TimestampFormatHeadersIO", - ) - ], - members={ - "memberEpochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberEpochSeconds" - ), - ], - }, - "memberHttpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberHttpDate" - ), - ], - }, - "memberDateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberDateTime" - ), - ], - }, - "defaultFormat": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-defaultFormat") - ], - }, - "targetEpochSeconds": { - "target": EPOCH_SECONDS, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-targetEpochSeconds" - ) - ], - }, - "targetHttpDate": { - "target": HTTP_DATE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetHttpDate") - ], - }, - "targetDateTime": { - "target": DATE_TIME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetDateTime") - ], - }, - }, -) - -TIMESTAMP_FORMAT_HEADERS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#TimestampFormatHeadersOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#TimestampFormatHeadersIO", - ) - ], - members={ - "memberEpochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberEpochSeconds" - ), - ], - }, - "memberHttpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberHttpDate" - ), - ], - }, - "memberDateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time"), - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-memberDateTime" - ), - ], - }, - "defaultFormat": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-defaultFormat") - ], - }, - "targetEpochSeconds": { - "target": EPOCH_SECONDS, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#httpHeader"), value="X-targetEpochSeconds" - ) - ], - }, - "targetHttpDate": { - "target": HTTP_DATE, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetHttpDate") - ], - }, - "targetDateTime": { - "target": DATE_TIME, - "traits": [ - Trait.new(id=ShapeID("smithy.api#httpHeader"), value="X-targetDateTime") - ], - }, - }, -) - -TIMESTAMP_FORMAT_HEADERS = Schema( - id=ShapeID("aws.protocoltests.restxml#TimestampFormatHeaders"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/TimestampFormatHeaders", "method": "POST"} - ), - ) - ], -) - -XML_ATTRIBUTES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlAttributesRequest", - ) - ], - members={ - "foo": {"target": STRING}, - "attr": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="test"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - }, - }, -) - -XML_ATTRIBUTES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlAttributesResponse", - ) - ], - members={ - "foo": {"target": STRING}, - "attr": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="test"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - }, - }, -) - -XML_ATTRIBUTES = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlAttributes"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlAttributes", "method": "PUT"}), - ) - ], -) - -XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesInMiddlePayloadRequest"), - members={ - "foo": {"target": STRING}, - "attr": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="test"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - }, - "baz": {"target": STRING}, - }, -) - -XML_ATTRIBUTES_IN_MIDDLE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesInMiddleInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlAttributesInMiddleRequest", - ) - ], - members={ - "payload": { - "target": XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesInMiddlePayloadResponse"), - members={ - "foo": {"target": STRING}, - "attr": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="test"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - }, - "baz": {"target": STRING}, - }, -) - -XML_ATTRIBUTES_IN_MIDDLE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesInMiddleOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlAttributesInMiddleResponse", - ) - ], - members={ - "payload": { - "target": XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -XML_ATTRIBUTES_IN_MIDDLE = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesInMiddle"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlAttributesInMiddle", "method": "PUT"}), - ) - ], -) - -XML_ATTRIBUTES_PAYLOAD_REQUEST = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesPayloadRequest"), - members={ - "foo": {"target": STRING}, - "attr": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="test"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - }, - }, -) - -XML_ATTRIBUTES_ON_PAYLOAD_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesOnPayloadInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlAttributesOnPayloadRequest", - ) - ], - members={ - "payload": { - "target": XML_ATTRIBUTES_PAYLOAD_REQUEST, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -XML_ATTRIBUTES_PAYLOAD_RESPONSE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesPayloadResponse"), - members={ - "foo": {"target": STRING}, - "attr": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="test"), - Trait.new(id=ShapeID("smithy.api#xmlAttribute")), - ], - }, - }, -) - -XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesOnPayloadOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlAttributesOnPayloadResponse", - ) - ], - members={ - "payload": { - "target": XML_ATTRIBUTES_PAYLOAD_RESPONSE, - "traits": [Trait.new(id=ShapeID("smithy.api#httpPayload"))], - } - }, -) - -XML_ATTRIBUTES_ON_PAYLOAD = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlAttributesOnPayload"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlAttributesOnPayload", "method": "PUT"}), - ) - ], -) - -XML_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlBlobsRequest", - ) - ], - members={"data": {"target": BLOB}}, -) - -XML_BLOBS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlBlobsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlBlobsResponse", - ) - ], - members={"data": {"target": BLOB}}, -) - -XML_BLOBS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlBlobs"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlBlobs", "method": "POST"}), - ) - ], -) - -XML_EMPTY_BLOBS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyBlobsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyBlobsRequest", - ) - ], - members={"data": {"target": BLOB}}, -) - -XML_EMPTY_BLOBS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyBlobsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyBlobsResponse", - ) - ], - members={"data": {"target": BLOB}}, -) - -XML_EMPTY_BLOBS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyBlobs"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlEmptyBlobs", "method": "POST"}), - ) - ], -) - -STRUCTURE_LIST_MEMBER = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#StructureListMember"), - members={ - "a": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="value")], - }, - "b": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="other")], - }, - }, -) - -STRUCTURE_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#StructureList"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRUCTURE_LIST_MEMBER, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="item")], - } - }, -) - -NESTED_STRING_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.shared#NestedStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING_LIST}}, -) - -XML_EMPTY_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyListsRequest", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - "flattenedStructureList": { - "target": STRUCTURE_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - }, -) - -XML_EMPTY_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyListsResponse", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - "flattenedStructureList": { - "target": STRUCTURE_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - }, -) - -XML_EMPTY_LISTS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyLists"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlEmptyLists", "method": "PUT"}), - ) - ], -) - -GREETING_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, -) - -XML_MAPS_INPUT_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapsInputOutputMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, -) - -XML_EMPTY_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyMapsRequest", - ) - ], - members={"myMap": {"target": XML_MAPS_INPUT_OUTPUT_MAP}}, -) - -XML_EMPTY_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyMapsResponse", - ) - ], - members={"myMap": {"target": XML_MAPS_INPUT_OUTPUT_MAP}}, -) - -XML_EMPTY_MAPS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyMaps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlEmptyMaps", "method": "POST"}), - ) - ], -) - -XML_EMPTY_STRINGS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyStringsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyStringsRequest", - ) - ], - members={"emptyString": {"target": STRING}}, -) - -XML_EMPTY_STRINGS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyStringsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEmptyStringsResponse", - ) - ], - members={"emptyString": {"target": STRING}}, -) - -XML_EMPTY_STRINGS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlEmptyStrings"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlEmptyStrings", "method": "PUT"}), - ) - ], -) - -FOO_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#FooEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) - -XML_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEnumsRequest", - ) - ], - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, -) - -XML_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlEnumsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlEnumsResponse", - ) - ], - members={ - "fooEnum1": {"target": FOO_ENUM}, - "fooEnum2": {"target": FOO_ENUM}, - "fooEnum3": {"target": FOO_ENUM}, - "fooEnumList": {"target": FOO_ENUM_LIST}, - "fooEnumSet": {"target": FOO_ENUM_SET}, - "fooEnumMap": {"target": FOO_ENUM_MAP}, - }, -) - -XML_ENUMS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlEnums"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlEnums", "method": "PUT"}), - ) - ], -) - -INTEGER_ENUM_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER_ENUM}}, -) - -INTEGER_ENUM_SET = Schema.collection( - id=ShapeID("aws.protocoltests.shared#IntegerEnumSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) - -XML_INT_ENUMS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlIntEnumsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlIntEnumsRequest", - ) - ], - members={ - "intEnum1": {"target": INTEGER_ENUM}, - "intEnum2": {"target": INTEGER_ENUM}, - "intEnum3": {"target": INTEGER_ENUM}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "intEnumSet": {"target": INTEGER_ENUM_SET}, - "intEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -XML_INT_ENUMS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlIntEnumsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlIntEnumsResponse", - ) - ], - members={ - "intEnum1": {"target": INTEGER_ENUM}, - "intEnum2": {"target": INTEGER_ENUM}, - "intEnum3": {"target": INTEGER_ENUM}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "intEnumSet": {"target": INTEGER_ENUM_SET}, - "intEnumMap": {"target": INTEGER_ENUM_MAP}, - }, -) - -XML_INT_ENUMS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlIntEnums"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlIntEnums", "method": "PUT"}), - ) - ], -) - -XML_LISTS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlListsRequest", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - "flattenedStructureList": { - "target": STRUCTURE_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - }, -) - -XML_LISTS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlListsResponse", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "renamedListMembers": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="renamed")], - }, - "flattenedList": { - "target": RENAMED_LIST_MEMBERS, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedList2": { - "target": RENAMED_LIST_MEMBERS, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="customName"), - Trait.new(id=ShapeID("smithy.api#xmlFlattened")), - ], - }, - "flattenedListWithMemberNamespace": { - "target": LIST_WITH_MEMBER_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "flattenedListWithNamespace": { - "target": LIST_WITH_NAMESPACE, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - "structureList": { - "target": STRUCTURE_LIST, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="myStructureList") - ], - }, - "flattenedStructureList": { - "target": STRUCTURE_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlFlattened"))], - }, - }, -) - -XML_LISTS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlLists"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlLists", "method": "PUT"}), - ) - ], -) - -XML_MAPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlMapsRequest", - ) - ], - members={"myMap": {"target": XML_MAPS_INPUT_OUTPUT_MAP}}, -) - -XML_MAPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlMapsResponse", - ) - ], - members={"myMap": {"target": XML_MAPS_INPUT_OUTPUT_MAP}}, -) - -XML_MAPS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlMaps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlMaps", "method": "POST"}), - ) - ], -) - -XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapsXmlNameInputOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="Attribute")], - }, - "value": { - "target": GREETING_STRUCT, - "traits": [Trait.new(id=ShapeID("smithy.api#xmlName"), value="Setting")], - }, - }, -) - -XML_MAPS_XML_NAME_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapsXmlNameInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlMapsXmlNameRequest", - ) - ], - members={"myMap": {"target": XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP}}, -) - -XML_MAPS_XML_NAME_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapsXmlNameOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlMapsXmlNameResponse", - ) - ], - members={"myMap": {"target": XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP}}, -) - -XML_MAPS_XML_NAME = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlMapsXmlName"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlMapsXmlName", "method": "POST"}), - ) - ], -) - -XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapWithXmlNamespaceInputOutputMap"), - shape_type=ShapeType.MAP, - members={ - "key": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="K"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-key.example.com"}), - ), - ], - }, - "value": { - "target": STRING, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="V"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-value.example.com"}), - ), - ], - }, - }, -) - -XML_MAP_WITH_XML_NAMESPACE_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapWithXmlNamespaceInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlMapWithXmlNamespaceRequest", - ) - ], - members={ - "myMap": { - "target": XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-member.example.com"}), - ), - ], - } - }, -) - -XML_MAP_WITH_XML_NAMESPACE_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlMapWithXmlNamespaceOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlMapWithXmlNamespaceResponse", - ) - ], - members={ - "myMap": { - "target": XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#xmlName"), value="KVP"), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "https://the-member.example.com"}), - ), - ], - } - }, -) - -XML_MAP_WITH_XML_NAMESPACE = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlMapWithXmlNamespace"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType( - {"uri": "/XmlMapWithXmlNamespace", "method": "POST"} - ), - ) - ], -) - -XML_NAMESPACED_LIST = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlNamespacedList"), - shape_type=ShapeType.LIST, - members={ - "member": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://bux.com"}), - ) - ], - } - }, -) - -XML_NAMESPACE_NESTED = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlNamespaceNested"), - traits=[ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ) - ], - members={ - "foo": { - "target": STRING, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://baz.com", "prefix": "baz"}), - ) - ], - }, - "values": { - "target": XML_NAMESPACED_LIST, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://qux.com"}), - ) - ], - }, - }, -) - -XML_NAMESPACES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlNamespacesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlNamespacesRequest", - ), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ), - ], - members={"nested": {"target": XML_NAMESPACE_NESTED}}, -) - -XML_NAMESPACES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlNamespacesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlNamespacesResponse", - ), - Trait.new( - id=ShapeID("smithy.api#xmlNamespace"), - value=MappingProxyType({"uri": "http://foo.com"}), - ), - ], - members={"nested": {"target": XML_NAMESPACE_NESTED}}, -) - -XML_NAMESPACES = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlNamespaces"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlNamespaces", "method": "POST"}), - ) - ], -) - -XML_TIMESTAMPS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlTimestampsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlTimestampsRequest", - ) - ], - members={ - "normal": {"target": TIMESTAMP}, - "dateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "dateTimeOnTarget": {"target": DATE_TIME}, - "epochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochSecondsOnTarget": {"target": EPOCH_SECONDS}, - "httpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "httpDateOnTarget": {"target": HTTP_DATE}, - }, -) - -XML_TIMESTAMPS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlTimestampsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlTimestampsResponse", - ) - ], - members={ - "normal": {"target": TIMESTAMP}, - "dateTime": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time") - ], - }, - "dateTimeOnTarget": {"target": DATE_TIME}, - "epochSeconds": { - "target": TIMESTAMP, - "traits": [ - Trait.new( - id=ShapeID("smithy.api#timestampFormat"), value="epoch-seconds" - ) - ], - }, - "epochSecondsOnTarget": {"target": EPOCH_SECONDS}, - "httpDate": { - "target": TIMESTAMP, - "traits": [ - Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="http-date") - ], - }, - "httpDateOnTarget": {"target": HTTP_DATE}, - }, -) - -XML_TIMESTAMPS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlTimestamps"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlTimestamps", "method": "POST"}), - ) - ], -) - -XML_NESTED_UNION_STRUCT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlNestedUnionStruct"), - members={ - "stringValue": {"target": STRING}, - "booleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": {"target": DOUBLE}, - }, -) - -XML_UNION_SHAPE = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlUnionShape"), - shape_type=ShapeType.UNION, - members={ - "stringValue": {"target": STRING}, - "booleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "shortValue": {"target": SHORT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "floatValue": {"target": FLOAT}, - "doubleValue": {"target": DOUBLE}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "unionValue": None, - "structValue": {"target": XML_NESTED_UNION_STRUCT}, - }, -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#RecursiveShapesInputOutputNested1"), - members={ - "foo": {"target": STRING}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "nested": None, - }, -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#RecursiveShapesInputOutputNested2"), - members={ - "bar": {"target": STRING}, - "recursiveMember": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}, - }, -) - -XML_UNIONS_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlUnionsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlUnionsRequest", - ) - ], - members={"unionValue": {"target": XML_UNION_SHAPE}}, -) - -XML_UNIONS_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#XmlUnionsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#XmlUnionsResponse", - ) - ], - members={"unionValue": {"target": XML_UNION_SHAPE}}, -) - -RECURSIVE_SHAPES_INPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#RecursiveShapesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#RecursiveShapesRequest", - ) - ], - members={"nested": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}}, -) - -RECURSIVE_SHAPES_OUTPUT = Schema.collection( - id=ShapeID("aws.protocoltests.restxml#RecursiveShapesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="aws.protocoltests.restxml#RecursiveShapesResponse", - ) - ], - members={"nested": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}}, -) - -XML_UNIONS = Schema( - id=ShapeID("aws.protocoltests.restxml#XmlUnions"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/XmlUnions", "method": "PUT"}), - ) - ], -) - -RECURSIVE_SHAPES = Schema( - id=ShapeID("aws.protocoltests.restxml#RecursiveShapes"), - shape_type=ShapeType.OPERATION, - traits=[ - Trait.new( - id=ShapeID("smithy.api#http"), - value=MappingProxyType({"uri": "/RecursiveShapes", "method": "PUT"}), - ) - ], -) - -REST_XML = Schema( - id=ShapeID("aws.protocoltests.restxml#RestXml"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new( - id=ShapeID("aws.auth#sigv4"), value=MappingProxyType({"name": "restxml"}) - ), - Trait.new(id=ShapeID("aws.protocols#restXml")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( - { - "Region": MappingProxyType( - { - "builtIn": "AWS::Region", - "required": False, - "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", - "type": "string", - } - ), - "UseDualStack": MappingProxyType( - { - "builtIn": "AWS::UseDualStack", - "required": True, - "default": False, - "documentation": "Whether to use dual-stack.", - "type": "boolean", - } - ), - "UseFIPS": MappingProxyType( - { - "builtIn": "AWS::UseFIPS", - "required": True, - "default": False, - "documentation": "Whether to use FIPS-compliant regional endpoint.", - "type": "boolean", - } - ), - "Endpoint": MappingProxyType( - { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Override the endpoint.", - "type": "string", - } - ), - } - ), - "conditions": ( - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Endpoint"}),), - } - ), - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "Region"}),), - } - ), - MappingProxyType( - { - "fn": "aws.partition", - "argv": (MappingProxyType({"ref": "Region"}),), - "assign": "PartitionResult", - } - ), - MappingProxyType( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( + 18, + n1, + _RSION, + 0, + (_f, _ne), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( + 18, + n1, + _RSIONe, + 0, + (_ba, _rM), + ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), +) + +XML_UNIONS_INPUT = (18, n1, _XUI, {_sSI: _aXUR}, (_uV,), ((XML_UNION_SHAPE, 0),)) + +XML_UNIONS_OUTPUT = (18, n1, _XUO, {_sSI: _aXURw}, (_uV,), ((XML_UNION_SHAPE, 0),)) + +RECURSIVE_SHAPES_INPUT = ( + 18, + n1, + _RSI, + {_sSI: _aRSR}, + (_ne,), + ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES_OUTPUT = ( + 18, + n1, + _RSO, + {_sSI: _aRSRw}, + (_ne,), + ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +XML_UNIONS = ( + 23, + n1, + _XU, + {_s: MappingProxyType({"uri": "/XmlUnions", "method": "PUT"})}, + XML_UNIONS_INPUT, + XML_UNIONS_OUTPUT, + (), +) + +RECURSIVE_SHAPES = ( + 23, + n1, + _RS, + {_s: MappingProxyType({"uri": "/RecursiveShapes", "method": "PUT"})}, + RECURSIVE_SHAPES_INPUT, + RECURSIVE_SHAPES_OUTPUT, + (), +) + +REST_XML = ( + 21, + n1, + _RX, + { + _aw: MappingProxyType({"name": "restxml"}), + _aX: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "Region": MappingProxyType( { - "fn": "booleanEquals", - "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + "builtIn": "AWS::Region", + "required": False, + "documentation": "The AWS Region. This is a default regional AWS endpointRuleSet.", + "type": "string", } ), - MappingProxyType( + "UseDualStack": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType({"ref": "UseDualStack"}), - True, - ), - } - ), - MappingProxyType( - { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsDualStack", - ), - } - ), - True, - ), + "builtIn": "AWS::UseDualStack", + "required": True, + "default": False, + "documentation": "Whether to use dual-stack.", + "type": "boolean", } ), - MappingProxyType( + "UseFIPS": MappingProxyType( { - "fn": "booleanEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "supportsFIPS", - ), - } - ), - True, - ), + "builtIn": "AWS::UseFIPS", + "required": True, + "default": False, + "documentation": "Whether to use FIPS-compliant regional endpoint.", + "type": "boolean", } ), - MappingProxyType( + "Endpoint": MappingProxyType( { - "fn": "stringEquals", - "argv": ( - MappingProxyType( - { - "fn": "getAttr", - "argv": ( - MappingProxyType( - {"ref": "PartitionResult"} - ), - "name", - ), - } - ), - "aws-us-gov", - ), + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Override the endpoint.", + "type": "string", } ), + } + ), + "conditions": ( + MappingProxyType( + { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "Endpoint"}),), + } ), - "results": ( - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: FIPS and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://restxml-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS and DualStack are enabled, but this partition does not support one or both", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": "https://restxml.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + MappingProxyType( + {"fn": "isSet", "argv": (MappingProxyType({"ref": "Region"}),)} + ), + MappingProxyType( + { + "fn": "aws.partition", + "argv": (MappingProxyType({"ref": "Region"}),), + "assign": "PartitionResult", + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseFIPS"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": (MappingProxyType({"ref": "UseDualStack"}), True), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://restxml-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsDualStack", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "FIPS is enabled but this partition does not support FIPS", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "booleanEquals", + "argv": ( + MappingProxyType( { - "url": "https://restxml.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "supportsFIPS", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "DualStack is enabled but this partition does not support DualStack", - "type": "error", - } - ), - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( + True, + ), + } + ), + MappingProxyType( + { + "fn": "stringEquals", + "argv": ( + MappingProxyType( { - "url": "https://restxml.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "fn": "getAttr", + "argv": ( + MappingProxyType( + {"ref": "PartitionResult"} + ), + "name", + ), } ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "Invalid Configuration: Missing Region", - "type": "error", - } - ), + "aws-us-gov", + ), + } ), - "root": 2, - "nodeCount": 14, - "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", - } - ), - ), - Trait.new( - id=ShapeID("aws.api#service"), - value=MappingProxyType({"sdkId": "Rest Xml Protocol"}), + ), + "results": ( + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: FIPS and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Dualstack and custom endpoint are not supported", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": MappingProxyType({"ref": "Endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxml-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS and DualStack are enabled, but this partition does not support one or both", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxml.{Region}.amazonaws.com", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxml-fips.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "FIPS is enabled but this partition does not support FIPS", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxml.{Region}.{PartitionResult#dualStackDnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "DualStack is enabled but this partition does not support DualStack", + "type": "error", + } + ), + MappingProxyType( + { + "conditions": (), + "endpoint": MappingProxyType( + { + "url": "https://restxml.{Region}.{PartitionResult#dnsSuffix}", + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), + } + ), + "type": "endpoint", + } + ), + MappingProxyType( + { + "conditions": (), + "error": "Invalid Configuration: Missing Region", + "type": "error", + } + ), + ), + "root": 2, + "nodeCount": 14, + "nodes": "/////wAAAAH/////AAAAAAAAAA0AAAADAAAAAQAAAAQF9eEMAAAAAgAAAAUF9eEMAAAAAwAAAAgAAAAGAAAABAAAAAcF9eELAAAABQX14QkF9eEKAAAABAAAAAsAAAAJAAAABgAAAAoF9eEIAAAABwX14QYF9eEHAAAABQAAAAwF9eEFAAAABgX14QQF9eEFAAAAAwX14QEAAAAOAAAABAX14QIF9eED", + } ), - ], -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["nested"] = Schema.member( - id=RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.id.with_member("nested"), - target=RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, - index=1, -) - -XML_UNION_SHAPE.members["unionValue"] = Schema.member( - id=XML_UNION_SHAPE.id.with_member("unionValue"), target=XML_UNION_SHAPE, index=8 + _aws: MappingProxyType({"sdkId": "Rest Xml Protocol"}), + }, ) diff --git a/codegen-output/rest-xml/src/restxml/models.py b/codegen-output/rest-xml/src/restxml/models.py index 54ab9049e..03dcbe6cd 100644 --- a/codegen-output/rest-xml/src/restxml/models.py +++ b/codegen-output/rest-xml/src/restxml/models.py @@ -6,6 +6,7 @@ import logging from typing import Any, Literal, Self, Union +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import TypeRegistry from smithy_core.exceptions import ModeledError, SerializationError @@ -248,7 +249,7 @@ class ServiceError(ModeledError): def _serialize_boolean_list( serializer: ShapeSerializer, schema: Schema, value: list[bool] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_boolean(member_schema, e) @@ -258,7 +259,7 @@ def _deserialize_boolean_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[bool]: result: list[bool] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -274,7 +275,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_double_list( serializer: ShapeSerializer, schema: Schema, value: list[float] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_double(member_schema, e) @@ -284,7 +285,7 @@ def _deserialize_double_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[float]: result: list[float] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -308,7 +309,7 @@ class FooEnum(UnknownEnumMixin, StrEnum): def _serialize_foo_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -318,7 +319,7 @@ def _deserialize_foo_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -340,7 +341,7 @@ class IntegerEnum(UnknownEnumMixin, IntEnum): def _serialize_integer_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -350,7 +351,7 @@ def _deserialize_integer_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -366,7 +367,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -376,7 +377,7 @@ def _deserialize_integer_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -392,7 +393,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -402,7 +403,7 @@ def _deserialize_integer_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -419,7 +420,7 @@ def _serialize_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -428,7 +429,7 @@ def _deserialize_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -444,7 +445,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -454,7 +455,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -470,7 +471,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -480,7 +481,7 @@ def _deserialize_string_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -496,7 +497,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_timestamp_list( serializer: ShapeSerializer, schema: Schema, value: list[datetime] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_timestamp(member_schema, e) @@ -506,7 +507,7 @@ def _deserialize_timestamp_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[datetime]: result: list[datetime] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -566,143 +567,77 @@ class AllQueryStringTypesInput: query_params_map_of_strings: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT).members_by_index if self.query_string is not None: - serializer.write_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryString"], - self.query_string, - ) + serializer.write_string(members[0], self.query_string) if self.query_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringList"], - self.query_string_list, - ) + _serialize_string_list(serializer, members[1], self.query_string_list) if self.query_string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringSet"], - self.query_string_set, - ) + _serialize_string_set(serializer, members[2], self.query_string_set) if self.query_byte is not None: - serializer.write_byte( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryByte"], - self.query_byte, - ) + serializer.write_byte(members[3], self.query_byte) if self.query_short is not None: - serializer.write_short( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryShort"], - self.query_short, - ) + serializer.write_short(members[4], self.query_short) if self.query_integer is not None: - serializer.write_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryInteger"], - self.query_integer, - ) + serializer.write_integer(members[5], self.query_integer) if self.query_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerList"], - self.query_integer_list, - ) + _serialize_integer_list(serializer, members[6], self.query_integer_list) if self.query_integer_set is not None: - _serialize_integer_set( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerSet"], - self.query_integer_set, - ) + _serialize_integer_set(serializer, members[7], self.query_integer_set) if self.query_long is not None: - serializer.write_long( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryLong"], - self.query_long, - ) + serializer.write_long(members[8], self.query_long) if self.query_float is not None: - serializer.write_float( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryFloat"], - self.query_float, - ) + serializer.write_float(members[9], self.query_float) if self.query_double is not None: - serializer.write_double( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDouble"], - self.query_double, - ) + serializer.write_double(members[10], self.query_double) if self.query_double_list is not None: - _serialize_double_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDoubleList"], - self.query_double_list, - ) + _serialize_double_list(serializer, members[11], self.query_double_list) if self.query_boolean is not None: - serializer.write_boolean( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryBoolean"], - self.query_boolean, - ) + serializer.write_boolean(members[12], self.query_boolean) if self.query_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryBooleanList"], - self.query_boolean_list, - ) + _serialize_boolean_list(serializer, members[13], self.query_boolean_list) if self.query_timestamp is not None: - serializer.write_timestamp( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryTimestamp"], - self.query_timestamp, - ) + serializer.write_timestamp(members[14], self.query_timestamp) if self.query_timestamp_list is not None: _serialize_timestamp_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryTimestampList"], - self.query_timestamp_list, + serializer, members[15], self.query_timestamp_list ) if self.query_enum is not None: - serializer.write_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnum"], - self.query_enum, - ) + serializer.write_string(members[16], self.query_enum) if self.query_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnumList"], - self.query_enum_list, - ) + _serialize_foo_enum_list(serializer, members[17], self.query_enum_list) if self.query_integer_enum is not None: - serializer.write_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerEnum"], - self.query_integer_enum, - ) + serializer.write_integer(members[18], self.query_integer_enum) if self.query_integer_enum_list is not None: _serialize_integer_enum_list( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerEnumList"], - self.query_integer_enum_list, + serializer, members[19], self.query_integer_enum_list ) if self.query_params_map_of_strings is not None: _serialize_string_map( - serializer, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryParamsMapOfStrings"], - self.query_params_map_of_strings, + serializer, members[20], self.query_params_map_of_strings ) @classmethod @@ -712,146 +647,98 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["query_string"] = de.read_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryString"] - ) + kwargs["query_string"] = de.read_string(members[0]) case 1: kwargs["query_string_list"] = _deserialize_string_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringList"], + de, members[1] ) case 2: - kwargs["query_string_set"] = _deserialize_string_set( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryStringSet"], - ) + kwargs["query_string_set"] = _deserialize_string_set(de, members[2]) case 3: - kwargs["query_byte"] = de.read_byte( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryByte"] - ) + kwargs["query_byte"] = de.read_byte(members[3]) case 4: - kwargs["query_short"] = de.read_short( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryShort"] - ) + kwargs["query_short"] = de.read_short(members[4]) case 5: - kwargs["query_integer"] = de.read_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryInteger"] - ) + kwargs["query_integer"] = de.read_integer(members[5]) case 6: kwargs["query_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryIntegerList" - ], + de, members[6] ) case 7: kwargs["query_integer_set"] = _deserialize_integer_set( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryIntegerSet"], + de, members[7] ) case 8: - kwargs["query_long"] = de.read_long( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryLong"] - ) + kwargs["query_long"] = de.read_long(members[8]) case 9: - kwargs["query_float"] = de.read_float( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryFloat"] - ) + kwargs["query_float"] = de.read_float(members[9]) case 10: - kwargs["query_double"] = de.read_double( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDouble"] - ) + kwargs["query_double"] = de.read_double(members[10]) case 11: kwargs["query_double_list"] = _deserialize_double_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryDoubleList"], + de, members[11] ) case 12: - kwargs["query_boolean"] = de.read_boolean( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryBoolean"] - ) + kwargs["query_boolean"] = de.read_boolean(members[12]) case 13: kwargs["query_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryBooleanList" - ], + de, members[13] ) case 14: - kwargs["query_timestamp"] = de.read_timestamp( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryTimestamp"] - ) + kwargs["query_timestamp"] = de.read_timestamp(members[14]) case 15: kwargs["query_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryTimestampList" - ], + de, members[15] ) case 16: - kwargs["query_enum"] = FooEnum( - de.read_string( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnum"] - ) - ) + kwargs["query_enum"] = FooEnum(de.read_string(members[16])) case 17: kwargs["query_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members["queryEnumList"], + de, members[17] ) case 18: kwargs["query_integer_enum"] = IntegerEnum( - de.read_integer( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryIntegerEnum" - ] - ) + de.read_integer(members[18]) ) case 19: kwargs["query_integer_enum_list"] = _deserialize_integer_enum_list( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryIntegerEnumList" - ], + de, members[19] ) case 20: kwargs["query_params_map_of_strings"] = _deserialize_string_map( - de, - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT.members[ - "queryParamsMapOfStrings" - ], + de, members[20] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ALL_QUERY_STRING_TYPES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -870,7 +757,7 @@ class AllQueryStringTypesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -882,27 +769,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ALL_QUERY_STRING_TYPES = APIOperation( input=AllQueryStringTypesInput, output=AllQueryStringTypesOutput, - schema=_SCHEMA_ALL_QUERY_STRING_TYPES, - input_schema=_SCHEMA_ALL_QUERY_STRING_TYPES_INPUT, - output_schema=_SCHEMA_ALL_QUERY_STRING_TYPES_OUTPUT, + static_schema=_SCHEMA_ALL_QUERY_STRING_TYPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -913,13 +796,12 @@ class PayloadWithXmlName: name: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_WITH_XML_NAME, self) + serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAME), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAME).members_by_index if self.name is not None: - serializer.write_string( - _SCHEMA_PAYLOAD_WITH_XML_NAME.members["name"], self.name - ) + serializer.write_string(members[0], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -928,18 +810,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAME) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_PAYLOAD_WITH_XML_NAME.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PAYLOAD_WITH_XML_NAME, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -950,13 +832,12 @@ class BodyWithXmlNameInput: nested: PayloadWithXmlName | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_BODY_WITH_XML_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_BODY_WITH_XML_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_BODY_WITH_XML_NAME_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_BODY_WITH_XML_NAME_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -965,16 +846,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_BODY_WITH_XML_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlName.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_BODY_WITH_XML_NAME_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -995,13 +878,12 @@ class BodyWithXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_BODY_WITH_XML_NAME_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_BODY_WITH_XML_NAME_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_BODY_WITH_XML_NAME_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_BODY_WITH_XML_NAME_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1010,28 +892,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_BODY_WITH_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlName.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_BODY_WITH_XML_NAME_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs BODY_WITH_XML_NAME = APIOperation( input=BodyWithXmlNameInput, output=BodyWithXmlNameOutput, - schema=_SCHEMA_BODY_WITH_XML_NAME, - input_schema=_SCHEMA_BODY_WITH_XML_NAME_INPUT, - output_schema=_SCHEMA_BODY_WITH_XML_NAME_OUTPUT, + static_schema=_SCHEMA_BODY_WITH_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1042,13 +923,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1057,18 +937,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1085,23 +965,18 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.header is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["Header"], self.header - ) + serializer.write_string(members[0], self.header) if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[1], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[2], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1110,26 +985,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["Header"] - ) + kwargs["header"] = de.read_string(members[0]) case 1: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[1]) case 2: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1142,20 +1015,19 @@ class ConstantAndVariableQueryStringInput: maybe_set: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT + ).members_by_index if self.baz is not None: - serializer.write_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members["baz"], - self.baz, - ) + serializer.write_string(members[0], self.baz) if self.maybe_set is not None: - serializer.write_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members["maybeSet"], - self.maybe_set, - ) + serializer.write_string(members[1], self.maybe_set) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1164,27 +1036,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["baz"] = de.read_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members["baz"] - ) + kwargs["baz"] = de.read_string(members[0]) case 1: - kwargs["maybe_set"] = de.read_string( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT.members[ - "maybeSet" - ] - ) + kwargs["maybe_set"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1203,7 +1069,9 @@ class ConstantAndVariableQueryStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1215,27 +1083,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONSTANT_AND_VARIABLE_QUERY_STRING = APIOperation( input=ConstantAndVariableQueryStringInput, output=ConstantAndVariableQueryStringOutput, - schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING, - input_schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, - output_schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, + static_schema=_SCHEMA_CONSTANT_AND_VARIABLE_QUERY_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1246,13 +1110,12 @@ class ConstantQueryStringInput: hello: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_QUERY_STRING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONSTANT_QUERY_STRING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONSTANT_QUERY_STRING_INPUT).members_by_index if self.hello is not None: - serializer.write_string( - _SCHEMA_CONSTANT_QUERY_STRING_INPUT.members["hello"], self.hello - ) + serializer.write_string(members[0], self.hello) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1261,20 +1124,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_QUERY_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hello"] = de.read_string( - _SCHEMA_CONSTANT_QUERY_STRING_INPUT.members["hello"] - ) + kwargs["hello"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_QUERY_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1293,7 +1154,7 @@ class ConstantQueryStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1305,27 +1166,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONSTANT_QUERY_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONSTANT_QUERY_STRING = APIOperation( input=ConstantQueryStringInput, output=ConstantQueryStringOutput, - schema=_SCHEMA_CONSTANT_QUERY_STRING, - input_schema=_SCHEMA_CONSTANT_QUERY_STRING_INPUT, - output_schema=_SCHEMA_CONSTANT_QUERY_STRING_OUTPUT, + static_schema=_SCHEMA_CONSTANT_QUERY_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1336,13 +1193,12 @@ class ContentTypeParametersInput: value: int | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT).members_by_index if self.value is not None: - serializer.write_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"], self.value - ) + serializer.write_integer(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1351,20 +1207,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_integer( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT.members["value"] - ) + kwargs["value"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1383,7 +1237,7 @@ class ContentTypeParametersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1395,27 +1249,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs CONTENT_TYPE_PARAMETERS = APIOperation( input=ContentTypeParametersInput, output=ContentTypeParametersOutput, - schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, - input_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_INPUT, - output_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS_OUTPUT, + static_schema=_SCHEMA_CONTENT_TYPE_PARAMETERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1424,7 +1274,7 @@ class DatetimeOffsetsInput: """Dataclass for DatetimeOffsetsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1436,13 +1286,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1463,13 +1314,12 @@ class DatetimeOffsetsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1478,30 +1328,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DATETIME_OFFSETS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_DATETIME_OFFSETS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DATETIME_OFFSETS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs DATETIME_OFFSETS = APIOperation( input=DatetimeOffsetsInput, output=DatetimeOffsetsOutput, - schema=_SCHEMA_DATETIME_OFFSETS, - input_schema=_SCHEMA_DATETIME_OFFSETS_INPUT, - output_schema=_SCHEMA_DATETIME_OFFSETS_OUTPUT, + static_schema=_SCHEMA_DATETIME_OFFSETS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1510,7 +1357,9 @@ class EmptyInputAndEmptyOutputInput: """Dataclass for EmptyInputAndEmptyOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1522,15 +1371,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1549,7 +1397,9 @@ class EmptyInputAndEmptyOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1561,27 +1411,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_INPUT_AND_EMPTY_OUTPUT = APIOperation( input=EmptyInputAndEmptyOutputInput, output=EmptyInputAndEmptyOutputOutput, - schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, - input_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, - output_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + static_schema=_SCHEMA_EMPTY_INPUT_AND_EMPTY_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1590,7 +1436,7 @@ class EndpointOperationInput: """Dataclass for EndpointOperationInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1602,13 +1448,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1627,7 +1474,7 @@ class EndpointOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1639,25 +1486,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_ENDPOINT_OPERATION_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_OPERATION = APIOperation( input=EndpointOperationInput, output=EndpointOperationOutput, - schema=_SCHEMA_ENDPOINT_OPERATION, - input_schema=_SCHEMA_ENDPOINT_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1669,17 +1514,15 @@ class EndpointWithHostLabelHeaderOperationInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT, self + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT + ).members_by_index if self.account_id is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT.members[ - "accountId" - ], - self.account_id, - ) + serializer.write_string(members[0], self.account_id) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1688,22 +1531,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["account_id"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT.members[ - "accountId" - ] - ) + kwargs["account_id"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1723,7 +1562,7 @@ class EndpointWithHostLabelHeaderOperationOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT, self + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -1736,27 +1575,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION = APIOperation( input=EndpointWithHostLabelHeaderOperationInput, output=EndpointWithHostLabelHeaderOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1767,14 +1602,16 @@ class EndpointWithHostLabelOperationInput: label: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT + ).members_by_index if self.label is not None: - serializer.write_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members["label"], - self.label, - ) + serializer.write_string(members[0], self.label) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1783,22 +1620,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["label"] = de.read_string( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT.members[ - "label" - ] - ) + kwargs["label"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1817,7 +1650,9 @@ class EndpointWithHostLabelOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1829,27 +1664,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs ENDPOINT_WITH_HOST_LABEL_OPERATION = APIOperation( input=EndpointWithHostLabelOperationInput, output=EndpointWithHostLabelOperationOutput, - schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, - input_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, - output_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + static_schema=_SCHEMA_ENDPOINT_WITH_HOST_LABEL_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1857,7 +1688,7 @@ def _serialize_foo_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -1866,7 +1697,7 @@ def _deserialize_foo_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -1886,15 +1717,12 @@ class FlattenedXmlMapInput: my_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FLATTENED_XML_MAP_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FLATTENED_XML_MAP_INPUT).members_by_index if self.my_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_INPUT.members["myMap"], - self.my_map, - ) + _serialize_foo_enum_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1903,18 +1731,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["my_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_FLATTENED_XML_MAP_INPUT.members["myMap"] - ) + kwargs["my_map"] = _deserialize_foo_enum_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FLATTENED_XML_MAP_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1935,15 +1763,12 @@ class FlattenedXmlMapOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FLATTENED_XML_MAP_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FLATTENED_XML_MAP_OUTPUT).members_by_index if self.my_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_OUTPUT.members["myMap"], - self.my_map, - ) + _serialize_foo_enum_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1952,30 +1777,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["my_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_FLATTENED_XML_MAP_OUTPUT.members["myMap"] - ) + kwargs["my_map"] = _deserialize_foo_enum_map(de, members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FLATTENED_XML_MAP_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLATTENED_XML_MAP = APIOperation( input=FlattenedXmlMapInput, output=FlattenedXmlMapOutput, - schema=_SCHEMA_FLATTENED_XML_MAP, - input_schema=_SCHEMA_FLATTENED_XML_MAP_INPUT, - output_schema=_SCHEMA_FLATTENED_XML_MAP_OUTPUT, + static_schema=_SCHEMA_FLATTENED_XML_MAP, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -1983,7 +1805,7 @@ def _serialize_flattened_xml_map_with_xml_name_input_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -1992,7 +1814,7 @@ def _deserialize_flattened_xml_map_with_xml_name_input_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2012,14 +1834,17 @@ class FlattenedXmlMapWithXmlNameInput: my_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT + ).members_by_index if self.my_map is not None: _serialize_flattened_xml_map_with_xml_name_input_output_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -2029,25 +1854,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_flattened_xml_map_with_xml_name_input_output_map( - de, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT.members[ - "myMap" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2068,14 +1890,17 @@ class FlattenedXmlMapWithXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT + ).members_by_index if self.my_map is not None: _serialize_flattened_xml_map_with_xml_name_input_output_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -2085,37 +1910,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_flattened_xml_map_with_xml_name_input_output_map( - de, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT.members[ - "myMap" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLATTENED_XML_MAP_WITH_XML_NAME = APIOperation( input=FlattenedXmlMapWithXmlNameInput, output=FlattenedXmlMapWithXmlNameOutput, - schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME, - input_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_INPUT, - output_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT, + static_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2125,7 +1944,7 @@ class FlattenedXmlMapWithXmlNamespaceInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, self + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -2138,15 +1957,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2154,7 +1972,7 @@ def _serialize_flattened_xml_map_with_xml_namespace_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2163,7 +1981,7 @@ def _deserialize_flattened_xml_map_with_xml_namespace_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2194,15 +2012,16 @@ class FlattenedXmlMapWithXmlNamespaceOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, self + hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT + ).members_by_index if self.my_map is not None: _serialize_flattened_xml_map_with_xml_namespace_output_map( - serializer, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -2212,37 +2031,31 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_flattened_xml_map_with_xml_namespace_output_map( - de, - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT.members[ - "myMap" - ], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLATTENED_XML_MAP_WITH_XML_NAMESPACE = APIOperation( input=FlattenedXmlMapWithXmlNamespaceInput, output=FlattenedXmlMapWithXmlNamespaceOutput, - schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE, - input_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT, - output_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, + static_schema=_SCHEMA_FLATTENED_XML_MAP_WITH_XML_NAMESPACE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2250,7 +2063,7 @@ def _serialize_foo_prefix_headers( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -2259,7 +2072,7 @@ def _deserialize_foo_prefix_headers( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2277,7 +2090,7 @@ class FractionalSecondsInput: """Dataclass for FractionalSecondsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2289,13 +2102,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2316,13 +2130,12 @@ class FractionalSecondsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2331,30 +2144,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FRACTIONAL_SECONDS = APIOperation( input=FractionalSecondsInput, output=FractionalSecondsOutput, - schema=_SCHEMA_FRACTIONAL_SECONDS, - input_schema=_SCHEMA_FRACTIONAL_SECONDS_INPUT, - output_schema=_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, + static_schema=_SCHEMA_FRACTIONAL_SECONDS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2363,7 +2173,7 @@ class GreetingWithErrorsInput: """Dataclass for GreetingWithErrorsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -2375,13 +2185,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2402,13 +2213,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2417,20 +2227,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2441,13 +2249,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2456,27 +2263,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("aws.protocoltests.restxml#InvalidGreeting"): InvalidGreeting, @@ -2484,7 +2289,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[_SCHEMA_INVALID_GREETING, _SCHEMA_COMPLEX_ERROR], ) @@ -2497,21 +2301,15 @@ class HttpEmptyPrefixHeadersInput: specific_header: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT).members_by_index if self.prefix_headers is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members["prefixHeaders"], - self.prefix_headers, - ) + _serialize_string_map(serializer, members[0], self.prefix_headers) if self.specific_header is not None: - serializer.write_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members["specificHeader"], - self.specific_header, - ) + serializer.write_string(members[1], self.specific_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2520,30 +2318,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["prefix_headers"] = _deserialize_string_map( - de, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members[ - "prefixHeaders" - ], - ) + kwargs["prefix_headers"] = _deserialize_string_map(de, members[0]) case 1: - kwargs["specific_header"] = de.read_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT.members[ - "specificHeader" - ] - ) + kwargs["specific_header"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2566,21 +2355,15 @@ class HttpEmptyPrefixHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT).members_by_index if self.prefix_headers is not None: - _serialize_string_map( - serializer, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members["prefixHeaders"], - self.prefix_headers, - ) + _serialize_string_map(serializer, members[0], self.prefix_headers) if self.specific_header is not None: - serializer.write_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members["specificHeader"], - self.specific_header, - ) + serializer.write_string(members[1], self.specific_header) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2589,42 +2372,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["prefix_headers"] = _deserialize_string_map( - de, - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members[ - "prefixHeaders" - ], - ) + kwargs["prefix_headers"] = _deserialize_string_map(de, members[0]) case 1: - kwargs["specific_header"] = de.read_string( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT.members[ - "specificHeader" - ] - ) + kwargs["specific_header"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_EMPTY_PREFIX_HEADERS = APIOperation( input=HttpEmptyPrefixHeadersInput, output=HttpEmptyPrefixHeadersOutput, - schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS, - input_schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_INPUT, - output_schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, + static_schema=_SCHEMA_HTTP_EMPTY_PREFIX_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2639,13 +2410,12 @@ class HttpEnumPayloadInput: payload: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_INPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2654,20 +2424,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = StringEnum( - de.read_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_INPUT.members["payload"] - ) - ) + kwargs["payload"] = StringEnum(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2688,13 +2456,12 @@ class HttpEnumPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2703,32 +2470,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = StringEnum( - de.read_string( - _SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT.members["payload"] - ) - ) + kwargs["payload"] = StringEnum(de.read_string(members[0])) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_ENUM_PAYLOAD = APIOperation( input=HttpEnumPayloadInput, output=HttpEnumPayloadOutput, - schema=_SCHEMA_HTTP_ENUM_PAYLOAD, - input_schema=_SCHEMA_HTTP_ENUM_PAYLOAD_INPUT, - output_schema=_SCHEMA_HTTP_ENUM_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_HTTP_ENUM_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2741,18 +2503,15 @@ class HttpPayloadTraitsInput: blob: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["blob"], self.blob - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2761,23 +2520,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT.members["blob"] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2800,18 +2557,15 @@ class HttpPayloadTraitsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["blob"], self.blob - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2820,35 +2574,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT.members["blob"] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_TRAITS = APIOperation( input=HttpPayloadTraitsInput, output=HttpPayloadTraitsOutput, - schema=_SCHEMA_HTTP_PAYLOAD_TRAITS, - input_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2861,20 +2610,19 @@ class HttpPayloadTraitsWithMediaTypeInput: blob: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members["blob"], - self.blob, - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2883,27 +2631,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT.members[ - "blob" - ] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2927,21 +2669,18 @@ class HttpPayloadTraitsWithMediaTypeOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, self + hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.blob is not None: - serializer.write_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members["blob"], - self.blob, - ) + serializer.write_blob(members[1], self.blob) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2950,41 +2689,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members[ - "foo" - ] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["blob"] = de.read_blob( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT.members[ - "blob" - ] - ) + kwargs["blob"] = de.read_blob(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = APIOperation( input=HttpPayloadTraitsWithMediaTypeInput, output=HttpPayloadTraitsWithMediaTypeOutput, - schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, - input_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -2995,14 +2723,16 @@ class HttpPayloadWithMemberXmlNameInput: nested: PayloadWithXmlName | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT + ).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT.members["nested"], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3011,18 +2741,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlName.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3043,14 +2773,16 @@ class HttpPayloadWithMemberXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT + ).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT.members["nested"], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3059,30 +2791,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlName.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_MEMBER_XML_NAME = APIOperation( input=HttpPayloadWithMemberXmlNameInput, output=HttpPayloadWithMemberXmlNameOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_MEMBER_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3095,16 +2824,15 @@ class NestedPayload: name: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_PAYLOAD, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_PAYLOAD), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_PAYLOAD).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_NESTED_PAYLOAD.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) if self.name is not None: - serializer.write_string(_SCHEMA_NESTED_PAYLOAD.members["name"], self.name) + serializer.write_string(members[1], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3113,23 +2841,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_PAYLOAD) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_NESTED_PAYLOAD.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case 1: - kwargs["name"] = de.read_string( - _SCHEMA_NESTED_PAYLOAD.members["name"] - ) + kwargs["name"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_PAYLOAD, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3140,13 +2866,14 @@ class HttpPayloadWithStructureInput: nested: NestedPayload | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3155,18 +2882,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = NestedPayload.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3187,14 +2914,14 @@ class HttpPayloadWithStructureOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT.members["nested"], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3203,30 +2930,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = NestedPayload.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_STRUCTURE = APIOperation( input=HttpPayloadWithStructureInput, output=HttpPayloadWithStructureOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_STRUCTURE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3235,16 +2959,16 @@ class UnionPayloadGreeting: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_UNION_PAYLOAD, self) + serializer.write_struct(hydrate(_SCHEMA_UNION_PAYLOAD), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string(_SCHEMA_UNION_PAYLOAD.members["greeting"], self.value) + members = hydrate(_SCHEMA_UNION_PAYLOAD).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string(_SCHEMA_UNION_PAYLOAD.members["greeting"]) - ) + members = hydrate(_SCHEMA_UNION_PAYLOAD).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -3279,7 +3003,7 @@ class _UnionPayloadDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> UnionPayload: self._result = None - deserializer.read_struct(_SCHEMA_UNION_PAYLOAD, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_UNION_PAYLOAD), self._consumer) if self._result is None: raise SerializationError( @@ -3311,13 +3035,12 @@ class HttpPayloadWithUnionInput: nested: UnionPayload | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3326,18 +3049,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = _UnionPayloadDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3358,13 +3081,12 @@ class HttpPayloadWithUnionOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3373,30 +3095,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = _UnionPayloadDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_UNION = APIOperation( input=HttpPayloadWithUnionInput, output=HttpPayloadWithUnionOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_UNION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3407,13 +3126,12 @@ class HttpPayloadWithXmlNameInput: nested: PayloadWithXmlName | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3422,18 +3140,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlName.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3454,13 +3172,14 @@ class HttpPayloadWithXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3469,30 +3188,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlName.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_XML_NAME = APIOperation( input=HttpPayloadWithXmlNameInput, output=HttpPayloadWithXmlNameOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3503,13 +3219,12 @@ class PayloadWithXmlNamespace: name: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE, self) + serializer.write_struct(hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE).members_by_index if self.name is not None: - serializer.write_string( - _SCHEMA_PAYLOAD_WITH_XML_NAMESPACE.members["name"], self.name - ) + serializer.write_string(members[0], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3518,18 +3233,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_PAYLOAD_WITH_XML_NAMESPACE.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3540,14 +3255,16 @@ class HttpPayloadWithXmlNamespaceInput: nested: PayloadWithXmlNamespace | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT + ).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT.members["nested"], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3556,18 +3273,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlNamespace.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3588,14 +3305,16 @@ class HttpPayloadWithXmlNamespaceOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT + ).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT.members["nested"], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3604,30 +3323,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlNamespace.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_XML_NAMESPACE = APIOperation( input=HttpPayloadWithXmlNamespaceInput, output=HttpPayloadWithXmlNamespaceOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3638,13 +3354,16 @@ class PayloadWithXmlNamespaceAndPrefix: name: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, self) + serializer.write_struct( + hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX + ).members_by_index if self.name is not None: - serializer.write_string( - _SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX.members["name"], self.name - ) + serializer.write_string(members[0], self.name) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3653,20 +3372,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["name"] = de.read_string( - _SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX.members["name"] - ) + kwargs["name"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3678,17 +3395,15 @@ class HttpPayloadWithXmlNamespaceAndPrefixInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT, self + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT + ).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT.members[ - "nested" - ], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3697,18 +3412,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlNamespaceAndPrefix.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3730,17 +3445,15 @@ class HttpPayloadWithXmlNamespaceAndPrefixOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT, self + hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT + ).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT.members[ - "nested" - ], - self.nested, - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3749,31 +3462,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = PayloadWithXmlNamespaceAndPrefix.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = APIOperation( input=HttpPayloadWithXmlNamespaceAndPrefixInput, output=HttpPayloadWithXmlNamespaceAndPrefixOutput, - schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, - input_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT, - output_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT, + static_schema=_SCHEMA_HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3786,20 +3495,15 @@ class HttpPrefixHeadersInput: foo_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.foo_map is not None: - _serialize_foo_prefix_headers( - serializer, - _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["fooMap"], - self.foo_map, - ) + _serialize_foo_prefix_headers(serializer, members[1], self.foo_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3808,23 +3512,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["foo_map"] = _deserialize_foo_prefix_headers( - de, _SCHEMA_HTTP_PREFIX_HEADERS_INPUT.members["fooMap"] - ) + kwargs["foo_map"] = _deserialize_foo_prefix_headers(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PREFIX_HEADERS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3847,20 +3549,15 @@ class HttpPrefixHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.foo_map is not None: - _serialize_foo_prefix_headers( - serializer, - _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["fooMap"], - self.foo_map, - ) + _serialize_foo_prefix_headers(serializer, members[1], self.foo_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3869,35 +3566,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["foo_map"] = _deserialize_foo_prefix_headers( - de, _SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT.members["fooMap"] - ) + kwargs["foo_map"] = _deserialize_foo_prefix_headers(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_PREFIX_HEADERS = APIOperation( input=HttpPrefixHeadersInput, output=HttpPrefixHeadersOutput, - schema=_SCHEMA_HTTP_PREFIX_HEADERS, - input_schema=_SCHEMA_HTTP_PREFIX_HEADERS_INPUT, - output_schema=_SCHEMA_HTTP_PREFIX_HEADERS_OUTPUT, + static_schema=_SCHEMA_HTTP_PREFIX_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -3910,20 +3602,17 @@ class HttpRequestWithFloatLabelsInput: double: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT).members_by_index if self.float_ is not None: - serializer.write_float( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["float"], - self.float_, - ) + serializer.write_float(members[0], self.float_) if self.double is not None: - serializer.write_double( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["double"], - self.double, - ) + serializer.write_double(members[1], self.double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3932,25 +3621,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["float_"] = de.read_float( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["float"] - ) + kwargs["float_"] = de.read_float(members[0]) case 1: - kwargs["double"] = de.read_double( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT.members["double"] - ) + kwargs["double"] = de.read_double(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3969,7 +3654,9 @@ class HttpRequestWithFloatLabelsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -3981,27 +3668,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_FLOAT_LABELS = APIOperation( input=HttpRequestWithFloatLabelsInput, output=HttpRequestWithFloatLabelsOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_FLOAT_LABELS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4015,21 +3698,18 @@ class HttpRequestWithGreedyLabelInPathInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.baz is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members["baz"], - self.baz, - ) + serializer.write_string(members[1], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4038,29 +3718,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members[ - "foo" - ] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["baz"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT.members[ - "baz" - ] - ) + kwargs["baz"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4080,7 +3752,7 @@ class HttpRequestWithGreedyLabelInPathOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -4093,27 +3765,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = APIOperation( input=HttpRequestWithGreedyLabelInPathInput, output=HttpRequestWithGreedyLabelInPathOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4143,49 +3811,33 @@ class HttpRequestWithLabelsInput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT).members_by_index if self.string is not None: - serializer.write_string( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["string"], self.string - ) + serializer.write_string(members[0], self.string) if self.short is not None: - serializer.write_short( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["short"], self.short - ) + serializer.write_short(members[1], self.short) if self.integer is not None: - serializer.write_integer( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["integer"], self.integer - ) + serializer.write_integer(members[2], self.integer) if self.long is not None: - serializer.write_long( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["long"], self.long - ) + serializer.write_long(members[3], self.long) if self.float_ is not None: - serializer.write_float( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["float"], self.float_ - ) + serializer.write_float(members[4], self.float_) if self.double is not None: - serializer.write_double( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["double"], self.double - ) + serializer.write_double(members[5], self.double) if self.boolean is not None: - serializer.write_boolean( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["boolean"], self.boolean - ) + serializer.write_boolean(members[6], self.boolean) if self.timestamp is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["timestamp"], - self.timestamp, - ) + serializer.write_timestamp(members[7], self.timestamp) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4194,55 +3846,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string"] = de.read_string( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["string"] - ) + kwargs["string"] = de.read_string(members[0]) case 1: - kwargs["short"] = de.read_short( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["short"] - ) + kwargs["short"] = de.read_short(members[1]) case 2: - kwargs["integer"] = de.read_integer( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["integer"] - ) + kwargs["integer"] = de.read_integer(members[2]) case 3: - kwargs["long"] = de.read_long( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["long"] - ) + kwargs["long"] = de.read_long(members[3]) case 4: - kwargs["float_"] = de.read_float( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["float"] - ) + kwargs["float_"] = de.read_float(members[4]) case 5: - kwargs["double"] = de.read_double( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["double"] - ) + kwargs["double"] = de.read_double(members[5]) case 6: - kwargs["boolean"] = de.read_boolean( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["boolean"] - ) + kwargs["boolean"] = de.read_boolean(members[6]) case 7: - kwargs["timestamp"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT.members["timestamp"] - ) + kwargs["timestamp"] = de.read_timestamp(members[7]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4261,7 +3897,7 @@ class HttpRequestWithLabelsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4273,27 +3909,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_LABELS = APIOperation( input=HttpRequestWithLabelsInput, output=HttpRequestWithLabelsOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4317,65 +3949,33 @@ class HttpRequestWithLabelsAndTimestampFormatInput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT), self ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT + ).members_by_index if self.member_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberEpochSeconds" - ], - self.member_epoch_seconds, - ) + serializer.write_timestamp(members[0], self.member_epoch_seconds) if self.member_http_date is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberHttpDate" - ], - self.member_http_date, - ) + serializer.write_timestamp(members[1], self.member_http_date) if self.member_date_time is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberDateTime" - ], - self.member_date_time, - ) + serializer.write_timestamp(members[2], self.member_date_time) if self.default_format is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "defaultFormat" - ], - self.default_format, - ) + serializer.write_timestamp(members[3], self.default_format) if self.target_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetEpochSeconds" - ], - self.target_epoch_seconds, - ) + serializer.write_timestamp(members[4], self.target_epoch_seconds) if self.target_http_date is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetHttpDate" - ], - self.target_http_date, - ) + serializer.write_timestamp(members[5], self.target_http_date) if self.target_date_time is not None: - serializer.write_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetDateTime" - ], - self.target_date_time, - ) + serializer.write_timestamp(members[6], self.target_date_time) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4384,65 +3984,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member_epoch_seconds"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberEpochSeconds" - ] - ) + kwargs["member_epoch_seconds"] = de.read_timestamp(members[0]) case 1: - kwargs["member_http_date"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberHttpDate" - ] - ) + kwargs["member_http_date"] = de.read_timestamp(members[1]) case 2: - kwargs["member_date_time"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "memberDateTime" - ] - ) + kwargs["member_date_time"] = de.read_timestamp(members[2]) case 3: - kwargs["default_format"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "defaultFormat" - ] - ) + kwargs["default_format"] = de.read_timestamp(members[3]) case 4: - kwargs["target_epoch_seconds"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetEpochSeconds" - ] - ) + kwargs["target_epoch_seconds"] = de.read_timestamp(members[4]) case 5: - kwargs["target_http_date"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetHttpDate" - ] - ) + kwargs["target_http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["target_date_time"] = de.read_timestamp( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT.members[ - "targetDateTime" - ] - ) + kwargs["target_date_time"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4462,7 +4033,7 @@ class HttpRequestWithLabelsAndTimestampFormatOutput: def serialize(self, serializer: ShapeSerializer): serializer.write_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, self + hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT), self ) def serialize_members(self, serializer: ShapeSerializer): @@ -4475,28 +4046,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, - consumer=_consumer, - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = APIOperation( input=HttpRequestWithLabelsAndTimestampFormatInput, output=HttpRequestWithLabelsAndTimestampFormatOutput, - schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, - input_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, - output_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, + static_schema=_SCHEMA_HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4505,7 +4071,7 @@ class HttpResponseCodeInput: """Dataclass for HttpResponseCodeInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_RESPONSE_CODE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_RESPONSE_CODE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4517,13 +4083,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_RESPONSE_CODE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_RESPONSE_CODE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4544,13 +4111,12 @@ class HttpResponseCodeOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT).members_by_index if self.status is not None: - serializer.write_integer( - _SCHEMA_HTTP_RESPONSE_CODE_OUTPUT.members["Status"], self.status - ) + serializer.write_integer(members[0], self.status) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4559,30 +4125,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["status"] = de.read_integer( - _SCHEMA_HTTP_RESPONSE_CODE_OUTPUT.members["Status"] - ) + kwargs["status"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_RESPONSE_CODE = APIOperation( input=HttpResponseCodeInput, output=HttpResponseCodeOutput, - schema=_SCHEMA_HTTP_RESPONSE_CODE, - input_schema=_SCHEMA_HTTP_RESPONSE_CODE_INPUT, - output_schema=_SCHEMA_HTTP_RESPONSE_CODE_OUTPUT, + static_schema=_SCHEMA_HTTP_RESPONSE_CODE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4593,13 +4156,12 @@ class HttpStringPayloadInput: payload: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_STRING_PAYLOAD_INPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4608,18 +4170,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_HTTP_STRING_PAYLOAD_INPUT.members["payload"] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_STRING_PAYLOAD_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4640,13 +4202,12 @@ class HttpStringPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT).members_by_index if self.payload is not None: - serializer.write_string( - _SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT.members["payload"], self.payload - ) + serializer.write_string(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4655,30 +4216,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["payload"] = de.read_string( - _SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT.members["payload"] - ) + kwargs["payload"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs HTTP_STRING_PAYLOAD = APIOperation( input=HttpStringPayloadInput, output=HttpStringPayloadOutput, - schema=_SCHEMA_HTTP_STRING_PAYLOAD, - input_schema=_SCHEMA_HTTP_STRING_PAYLOAD_INPUT, - output_schema=_SCHEMA_HTTP_STRING_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_HTTP_STRING_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4687,7 +4245,9 @@ class IgnoreQueryParamsInResponseInput: """Dataclass for IgnoreQueryParamsInResponseInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -4699,15 +4259,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4728,13 +4287,16 @@ class IgnoreQueryParamsInResponseOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, self) - + serializer.write_struct( + hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT), self + ) + def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT + ).members_by_index if self.baz is not None: - serializer.write_string( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT.members["baz"], self.baz - ) + serializer.write_string(members[0], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4743,32 +4305,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["baz"] = de.read_string( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT.members["baz"] - ) + kwargs["baz"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs IGNORE_QUERY_PARAMS_IN_RESPONSE = APIOperation( input=IgnoreQueryParamsInResponseInput, output=IgnoreQueryParamsInResponseOutput, - schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE, - input_schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, - output_schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, + static_schema=_SCHEMA_IGNORE_QUERY_PARAMS_IN_RESPONSE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -4809,116 +4366,61 @@ class InputAndOutputWithHeadersInput: header_enum_list: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT).members_by_index if self.header_string is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerString"], - self.header_string, - ) + serializer.write_string(members[0], self.header_string) if self.header_byte is not None: - serializer.write_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerByte"], - self.header_byte, - ) + serializer.write_byte(members[1], self.header_byte) if self.header_short is not None: - serializer.write_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerShort"], - self.header_short, - ) + serializer.write_short(members[2], self.header_short) if self.header_integer is not None: - serializer.write_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerInteger"], - self.header_integer, - ) + serializer.write_integer(members[3], self.header_integer) if self.header_long is not None: - serializer.write_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerLong"], - self.header_long, - ) + serializer.write_long(members[4], self.header_long) if self.header_float is not None: - serializer.write_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerFloat"], - self.header_float, - ) + serializer.write_float(members[5], self.header_float) if self.header_double is not None: - serializer.write_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerDouble"], - self.header_double, - ) + serializer.write_double(members[6], self.header_double) if self.header_true_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerTrueBool"], - self.header_true_bool, - ) + serializer.write_boolean(members[7], self.header_true_bool) if self.header_false_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerFalseBool"], - self.header_false_bool, - ) + serializer.write_boolean(members[8], self.header_false_bool) if self.header_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerStringList"], - self.header_string_list, - ) + _serialize_string_list(serializer, members[9], self.header_string_list) if self.header_string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerStringSet"], - self.header_string_set, - ) + _serialize_string_set(serializer, members[10], self.header_string_set) if self.header_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerList" - ], - self.header_integer_list, - ) + _serialize_integer_list(serializer, members[11], self.header_integer_list) if self.header_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerBooleanList" - ], - self.header_boolean_list, - ) + _serialize_boolean_list(serializer, members[12], self.header_boolean_list) if self.header_timestamp_list is not None: _serialize_timestamp_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerTimestampList" - ], - self.header_timestamp_list, + serializer, members[13], self.header_timestamp_list ) if self.header_enum is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerEnum"], - self.header_enum, - ) + serializer.write_string(members[14], self.header_enum) if self.header_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members["headerEnumList"], - self.header_enum_list, - ) + _serialize_foo_enum_list(serializer, members[15], self.header_enum_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4927,135 +4429,75 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header_string"] = de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerString" - ] - ) + kwargs["header_string"] = de.read_string(members[0]) case 1: - kwargs["header_byte"] = de.read_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerByte" - ] - ) + kwargs["header_byte"] = de.read_byte(members[1]) case 2: - kwargs["header_short"] = de.read_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerShort" - ] - ) + kwargs["header_short"] = de.read_short(members[2]) case 3: - kwargs["header_integer"] = de.read_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerInteger" - ] - ) + kwargs["header_integer"] = de.read_integer(members[3]) case 4: - kwargs["header_long"] = de.read_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerLong" - ] - ) + kwargs["header_long"] = de.read_long(members[4]) case 5: - kwargs["header_float"] = de.read_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerFloat" - ] - ) + kwargs["header_float"] = de.read_float(members[5]) case 6: - kwargs["header_double"] = de.read_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerDouble" - ] - ) + kwargs["header_double"] = de.read_double(members[6]) case 7: - kwargs["header_true_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerTrueBool" - ] - ) + kwargs["header_true_bool"] = de.read_boolean(members[7]) case 8: - kwargs["header_false_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerFalseBool" - ] - ) + kwargs["header_false_bool"] = de.read_boolean(members[8]) case 9: kwargs["header_string_list"] = _deserialize_string_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerStringList" - ], + de, members[9] ) case 10: kwargs["header_string_set"] = _deserialize_string_set( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerStringSet" - ], + de, members[10] ) case 11: kwargs["header_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerIntegerList" - ], + de, members[11] ) case 12: kwargs["header_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerBooleanList" - ], + de, members[12] ) case 13: kwargs["header_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerTimestampList" - ], + de, members[13] ) case 14: - kwargs["header_enum"] = FooEnum( - de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerEnum" - ] - ) - ) + kwargs["header_enum"] = FooEnum(de.read_string(members[14])) case 15: kwargs["header_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT.members[ - "headerEnumList" - ], + de, members[15] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5106,118 +4548,61 @@ class InputAndOutputWithHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT).members_by_index if self.header_string is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerString"], - self.header_string, - ) + serializer.write_string(members[0], self.header_string) if self.header_byte is not None: - serializer.write_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerByte"], - self.header_byte, - ) + serializer.write_byte(members[1], self.header_byte) if self.header_short is not None: - serializer.write_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerShort"], - self.header_short, - ) + serializer.write_short(members[2], self.header_short) if self.header_integer is not None: - serializer.write_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerInteger"], - self.header_integer, - ) + serializer.write_integer(members[3], self.header_integer) if self.header_long is not None: - serializer.write_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerLong"], - self.header_long, - ) + serializer.write_long(members[4], self.header_long) if self.header_float is not None: - serializer.write_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerFloat"], - self.header_float, - ) + serializer.write_float(members[5], self.header_float) if self.header_double is not None: - serializer.write_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerDouble"], - self.header_double, - ) + serializer.write_double(members[6], self.header_double) if self.header_true_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerTrueBool"], - self.header_true_bool, - ) + serializer.write_boolean(members[7], self.header_true_bool) if self.header_false_bool is not None: - serializer.write_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerFalseBool"], - self.header_false_bool, - ) + serializer.write_boolean(members[8], self.header_false_bool) if self.header_string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerStringList" - ], - self.header_string_list, - ) + _serialize_string_list(serializer, members[9], self.header_string_list) if self.header_string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerStringSet"], - self.header_string_set, - ) + _serialize_string_set(serializer, members[10], self.header_string_set) if self.header_integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerList" - ], - self.header_integer_list, - ) + _serialize_integer_list(serializer, members[11], self.header_integer_list) if self.header_boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerBooleanList" - ], - self.header_boolean_list, - ) + _serialize_boolean_list(serializer, members[12], self.header_boolean_list) if self.header_timestamp_list is not None: _serialize_timestamp_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerTimestampList" - ], - self.header_timestamp_list, + serializer, members[13], self.header_timestamp_list ) if self.header_enum is not None: - serializer.write_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerEnum"], - self.header_enum, - ) + serializer.write_string(members[14], self.header_enum) if self.header_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members["headerEnumList"], - self.header_enum_list, - ) + _serialize_foo_enum_list(serializer, members[15], self.header_enum_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5226,154 +4611,91 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["header_string"] = de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerString" - ] - ) + kwargs["header_string"] = de.read_string(members[0]) case 1: - kwargs["header_byte"] = de.read_byte( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerByte" - ] - ) + kwargs["header_byte"] = de.read_byte(members[1]) case 2: - kwargs["header_short"] = de.read_short( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerShort" - ] - ) + kwargs["header_short"] = de.read_short(members[2]) case 3: - kwargs["header_integer"] = de.read_integer( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerInteger" - ] - ) + kwargs["header_integer"] = de.read_integer(members[3]) case 4: - kwargs["header_long"] = de.read_long( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerLong" - ] - ) + kwargs["header_long"] = de.read_long(members[4]) case 5: - kwargs["header_float"] = de.read_float( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerFloat" - ] - ) + kwargs["header_float"] = de.read_float(members[5]) case 6: - kwargs["header_double"] = de.read_double( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerDouble" - ] - ) + kwargs["header_double"] = de.read_double(members[6]) case 7: - kwargs["header_true_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerTrueBool" - ] - ) + kwargs["header_true_bool"] = de.read_boolean(members[7]) case 8: - kwargs["header_false_bool"] = de.read_boolean( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerFalseBool" - ] - ) + kwargs["header_false_bool"] = de.read_boolean(members[8]) case 9: kwargs["header_string_list"] = _deserialize_string_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerStringList" - ], + de, members[9] ) case 10: kwargs["header_string_set"] = _deserialize_string_set( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerStringSet" - ], + de, members[10] ) case 11: kwargs["header_integer_list"] = _deserialize_integer_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerIntegerList" - ], + de, members[11] ) case 12: kwargs["header_boolean_list"] = _deserialize_boolean_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerBooleanList" - ], + de, members[12] ) case 13: kwargs["header_timestamp_list"] = _deserialize_timestamp_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerTimestampList" - ], + de, members[13] ) case 14: - kwargs["header_enum"] = FooEnum( - de.read_string( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerEnum" - ] - ) - ) + kwargs["header_enum"] = FooEnum(de.read_string(members[14])) case 15: kwargs["header_enum_list"] = _deserialize_foo_enum_list( - de, - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT.members[ - "headerEnumList" - ], + de, members[15] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs INPUT_AND_OUTPUT_WITH_HEADERS = APIOperation( input=InputAndOutputWithHeadersInput, output=InputAndOutputWithHeadersOutput, - schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS, - input_schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, - output_schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, + static_schema=_SCHEMA_INPUT_AND_OUTPUT_WITH_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_list_with_member_namespace( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -5383,7 +4705,7 @@ def _deserialize_list_with_member_namespace( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -5399,7 +4721,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_list_with_namespace( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -5409,7 +4731,7 @@ def _deserialize_list_with_namespace( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -5426,7 +4748,7 @@ def _serialize_nested_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, dict[str, str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_foo_enum_map(vs, value_schema, v)) @@ -5435,7 +4757,7 @@ def _deserialize_nested_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, dict[str, str]]: result: dict[str, dict[str, str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -5457,22 +4779,15 @@ class NestedXmlMapsInput: flat_nested_map: dict[str, dict[str, str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_XML_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_XML_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_XML_MAPS_INPUT).members_by_index if self.nested_map is not None: - _serialize_nested_map( - serializer, - _SCHEMA_NESTED_XML_MAPS_INPUT.members["nestedMap"], - self.nested_map, - ) + _serialize_nested_map(serializer, members[0], self.nested_map) if self.flat_nested_map is not None: - _serialize_nested_map( - serializer, - _SCHEMA_NESTED_XML_MAPS_INPUT.members["flatNestedMap"], - self.flat_nested_map, - ) + _serialize_nested_map(serializer, members[1], self.flat_nested_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5481,23 +4796,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_XML_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["nested_map"] = _deserialize_nested_map( - de, _SCHEMA_NESTED_XML_MAPS_INPUT.members["nestedMap"] - ) + kwargs["nested_map"] = _deserialize_nested_map(de, members[0]) case 1: - kwargs["flat_nested_map"] = _deserialize_nested_map( - de, _SCHEMA_NESTED_XML_MAPS_INPUT.members["flatNestedMap"] - ) + kwargs["flat_nested_map"] = _deserialize_nested_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_XML_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5520,22 +4833,15 @@ class NestedXmlMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_XML_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NESTED_XML_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_XML_MAPS_OUTPUT).members_by_index if self.nested_map is not None: - _serialize_nested_map( - serializer, - _SCHEMA_NESTED_XML_MAPS_OUTPUT.members["nestedMap"], - self.nested_map, - ) + _serialize_nested_map(serializer, members[0], self.nested_map) if self.flat_nested_map is not None: - _serialize_nested_map( - serializer, - _SCHEMA_NESTED_XML_MAPS_OUTPUT.members["flatNestedMap"], - self.flat_nested_map, - ) + _serialize_nested_map(serializer, members[1], self.flat_nested_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5544,35 +4850,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_XML_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["nested_map"] = _deserialize_nested_map( - de, _SCHEMA_NESTED_XML_MAPS_OUTPUT.members["nestedMap"] - ) + kwargs["nested_map"] = _deserialize_nested_map(de, members[0]) case 1: - kwargs["flat_nested_map"] = _deserialize_nested_map( - de, _SCHEMA_NESTED_XML_MAPS_OUTPUT.members["flatNestedMap"] - ) + kwargs["flat_nested_map"] = _deserialize_nested_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NESTED_XML_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NESTED_XML_MAPS = APIOperation( input=NestedXmlMapsInput, output=NestedXmlMapsOutput, - schema=_SCHEMA_NESTED_XML_MAPS, - input_schema=_SCHEMA_NESTED_XML_MAPS_INPUT, - output_schema=_SCHEMA_NESTED_XML_MAPS_OUTPUT, + static_schema=_SCHEMA_NESTED_XML_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5580,7 +4881,7 @@ def _serialize_nested_xml_map_with_xml_name_inner_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -5589,7 +4890,7 @@ def _deserialize_nested_xml_map_with_xml_name_inner_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -5606,7 +4907,7 @@ def _serialize_nested_xml_map_with_xml_name_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, dict[str, str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry( k, @@ -5620,7 +4921,7 @@ def _deserialize_nested_xml_map_with_xml_name_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, dict[str, str]]: result: dict[str, dict[str, str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -5642,16 +4943,15 @@ class NestedXmlMapWithXmlNameInput: nested_xml_map_with_xml_name_map: dict[str, dict[str, str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT).members_by_index if self.nested_xml_map_with_xml_name_map is not None: _serialize_nested_xml_map_with_xml_name_map( - serializer, - _SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT.members[ - "nestedXmlMapWithXmlNameMap" - ], - self.nested_xml_map_with_xml_name_map, + serializer, members[0], self.nested_xml_map_with_xml_name_map ) @classmethod @@ -5661,25 +4961,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested_xml_map_with_xml_name_map"] = ( - _deserialize_nested_xml_map_with_xml_name_map( - de, - _SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT.members[ - "nestedXmlMapWithXmlNameMap" - ], - ) + _deserialize_nested_xml_map_with_xml_name_map(de, members[0]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5700,16 +4995,15 @@ class NestedXmlMapWithXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT).members_by_index if self.nested_xml_map_with_xml_name_map is not None: _serialize_nested_xml_map_with_xml_name_map( - serializer, - _SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT.members[ - "nestedXmlMapWithXmlNameMap" - ], - self.nested_xml_map_with_xml_name_map, + serializer, members[0], self.nested_xml_map_with_xml_name_map ) @classmethod @@ -5719,37 +5013,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested_xml_map_with_xml_name_map"] = ( - _deserialize_nested_xml_map_with_xml_name_map( - de, - _SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT.members[ - "nestedXmlMapWithXmlNameMap" - ], - ) + _deserialize_nested_xml_map_with_xml_name_map(de, members[0]) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NESTED_XML_MAP_WITH_XML_NAME = APIOperation( input=NestedXmlMapWithXmlNameInput, output=NestedXmlMapWithXmlNameOutput, - schema=_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME, - input_schema=_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_INPUT, - output_schema=_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME_OUTPUT, + static_schema=_SCHEMA_NESTED_XML_MAP_WITH_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5758,7 +5044,7 @@ class NoInputAndNoOutputInput: """Dataclass for NoInputAndNoOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5770,15 +5056,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5797,7 +5082,7 @@ class NoInputAndNoOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5809,27 +5094,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_NO_OUTPUT = APIOperation( input=NoInputAndNoOutputInput, output=NoInputAndNoOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_NO_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5838,7 +5119,7 @@ class NoInputAndOutputInput: """Dataclass for NoInputAndOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5850,13 +5131,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5875,7 +5157,7 @@ class NoInputAndOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -5887,25 +5169,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_AND_OUTPUT = APIOperation( input=NoInputAndOutputInput, output=NoInputAndOutputOutput, - schema=_SCHEMA_NO_INPUT_AND_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_AND_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_AND_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -5920,25 +5200,20 @@ class NullAndEmptyHeadersClientInput: c: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -5947,30 +5222,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -5995,25 +5264,20 @@ class NullAndEmptyHeadersClientOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6022,42 +5286,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NULL_AND_EMPTY_HEADERS_CLIENT = APIOperation( input=NullAndEmptyHeadersClientInput, output=NullAndEmptyHeadersClientOutput, - schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT, - input_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, - output_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, + static_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_CLIENT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6072,25 +5327,20 @@ class NullAndEmptyHeadersServerInput: c: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6099,30 +5349,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6147,25 +5391,20 @@ class NullAndEmptyHeadersServerOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT).members_by_index if self.a is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["a"], self.a - ) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["b"], self.b - ) + serializer.write_string(members[1], self.b) if self.c is not None: - _serialize_string_list( - serializer, - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["c"], - self.c, - ) + _serialize_string_list(serializer, members[2], self.c) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6174,42 +5413,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case 2: - kwargs["c"] = _deserialize_string_list( - de, _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT.members["c"] - ) + kwargs["c"] = _deserialize_string_list(de, members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NULL_AND_EMPTY_HEADERS_SERVER = APIOperation( input=NullAndEmptyHeadersServerInput, output=NullAndEmptyHeadersServerOutput, - schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER, - input_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_INPUT, - output_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, + static_schema=_SCHEMA_NULL_AND_EMPTY_HEADERS_SERVER, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6222,20 +5452,19 @@ class OmitsNullSerializesEmptyStringInput: empty_string: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT + ).members_by_index if self.null_value is not None: - serializer.write_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members["nullValue"], - self.null_value, - ) + serializer.write_string(members[0], self.null_value) if self.empty_string is not None: - serializer.write_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members["emptyString"], - self.empty_string, - ) + serializer.write_string(members[1], self.empty_string) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6244,29 +5473,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["null_value"] = de.read_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members[ - "nullValue" - ] - ) + kwargs["null_value"] = de.read_string(members[0]) case 1: - kwargs["empty_string"] = de.read_string( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT.members[ - "emptyString" - ] - ) + kwargs["empty_string"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6285,7 +5506,9 @@ class OmitsNullSerializesEmptyStringOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6297,27 +5520,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OMITS_NULL_SERIALIZES_EMPTY_STRING = APIOperation( input=OmitsNullSerializesEmptyStringInput, output=OmitsNullSerializesEmptyStringOutput, - schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING, - input_schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, - output_schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, + static_schema=_SCHEMA_OMITS_NULL_SERIALIZES_EMPTY_STRING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6330,19 +5549,15 @@ class PutWithContentEncodingInput: data: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT).members_by_index if self.encoding is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"], - self.encoding, - ) + serializer.write_string(members[0], self.encoding) if self.data is not None: - serializer.write_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"], self.data - ) + serializer.write_string(members[1], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6351,25 +5566,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["encoding"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["encoding"] - ) + kwargs["encoding"] = de.read_string(members[0]) case 1: - kwargs["data"] = de.read_string( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT.members["data"] - ) + kwargs["data"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6388,7 +5599,7 @@ class PutWithContentEncodingOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6400,27 +5611,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs PUT_WITH_CONTENT_ENCODING = APIOperation( input=PutWithContentEncodingInput, output=PutWithContentEncodingOutput, - schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, - input_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_INPUT, - output_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING_OUTPUT, + static_schema=_SCHEMA_PUT_WITH_CONTENT_ENCODING, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6431,14 +5638,16 @@ class QueryIdempotencyTokenAutoFillInput: token: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT + ).members_by_index if self.token is not None: - serializer.write_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"], - self.token, - ) + serializer.write_string(members[0], self.token) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6447,20 +5656,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["token"] = de.read_string( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT.members["token"] - ) + kwargs["token"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6479,7 +5686,9 @@ class QueryIdempotencyTokenAutoFillOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6491,27 +5700,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = APIOperation( input=QueryIdempotencyTokenAutoFillInput, output=QueryIdempotencyTokenAutoFillOutput, - schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, - input_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, - output_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + static_schema=_SCHEMA_QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6519,7 +5724,7 @@ def _serialize_string_list_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_string_list(vs, value_schema, v)) @@ -6528,7 +5733,7 @@ def _deserialize_string_list_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str]]: result: dict[str, list[str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -6550,20 +5755,19 @@ class QueryParamsAsStringListMapInput: foo: dict[str, list[str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT + ).members_by_index if self.qux is not None: - serializer.write_string( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["qux"], self.qux - ) + serializer.write_string(members[0], self.qux) if self.foo is not None: - _serialize_string_list_map( - serializer, - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["foo"], - self.foo, - ) + _serialize_string_list_map(serializer, members[1], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6572,25 +5776,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["qux"] = de.read_string( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["qux"] - ) + kwargs["qux"] = de.read_string(members[0]) case 1: - kwargs["foo"] = _deserialize_string_list_map( - de, _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT.members["foo"] - ) + kwargs["foo"] = _deserialize_string_list_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6609,7 +5809,9 @@ class QueryParamsAsStringListMapOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6621,27 +5823,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_PARAMS_AS_STRING_LIST_MAP = APIOperation( input=QueryParamsAsStringListMapInput, output=QueryParamsAsStringListMapOutput, - schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP, - input_schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, - output_schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, + static_schema=_SCHEMA_QUERY_PARAMS_AS_STRING_LIST_MAP, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -6654,18 +5852,15 @@ class QueryPrecedenceInput: baz: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PRECEDENCE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_PRECEDENCE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_QUERY_PRECEDENCE_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_QUERY_PRECEDENCE_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.baz is not None: - _serialize_string_map( - serializer, _SCHEMA_QUERY_PRECEDENCE_INPUT.members["baz"], self.baz - ) + _serialize_string_map(serializer, members[1], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6674,23 +5869,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PRECEDENCE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_QUERY_PRECEDENCE_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["baz"] = _deserialize_string_map( - de, _SCHEMA_QUERY_PRECEDENCE_INPUT.members["baz"] - ) + kwargs["baz"] = _deserialize_string_map(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_PRECEDENCE_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6709,7 +5902,7 @@ class QueryPrecedenceOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_QUERY_PRECEDENCE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_QUERY_PRECEDENCE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -6721,32 +5914,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_QUERY_PRECEDENCE_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_QUERY_PRECEDENCE_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs QUERY_PRECEDENCE = APIOperation( input=QueryPrecedenceInput, output=QueryPrecedenceOutput, - schema=_SCHEMA_QUERY_PRECEDENCE, - input_schema=_SCHEMA_QUERY_PRECEDENCE_INPUT, - output_schema=_SCHEMA_QUERY_PRECEDENCE_OUTPUT, + static_schema=_SCHEMA_QUERY_PRECEDENCE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_renamed_list_members( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -6756,7 +5947,7 @@ def _deserialize_renamed_list_members( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -6794,67 +5985,39 @@ class SimpleScalarPropertiesInput: double_value: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[1], self.string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[9], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -6863,69 +6026,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -6964,67 +6103,39 @@ class SimpleScalarPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[1], self.string_value) if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[2], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[3], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[4], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[5], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[6], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[7], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[8], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[9], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7033,81 +6144,54 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[1]) case 2: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[2]) case 3: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[3]) case 4: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[4]) case 5: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[5]) case 6: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[6]) case 7: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[7]) case 8: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[8]) case 9: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_PROPERTIES = APIOperation( input=SimpleScalarPropertiesInput, output=SimpleScalarPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7130,50 +6214,30 @@ class TimestampFormatHeadersInput: target_date_time: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT).members_by_index if self.member_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberEpochSeconds"], - self.member_epoch_seconds, - ) + serializer.write_timestamp(members[0], self.member_epoch_seconds) if self.member_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberHttpDate"], - self.member_http_date, - ) + serializer.write_timestamp(members[1], self.member_http_date) if self.member_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberDateTime"], - self.member_date_time, - ) + serializer.write_timestamp(members[2], self.member_date_time) if self.default_format is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["defaultFormat"], - self.default_format, - ) + serializer.write_timestamp(members[3], self.default_format) if self.target_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetEpochSeconds"], - self.target_epoch_seconds, - ) + serializer.write_timestamp(members[4], self.target_epoch_seconds) if self.target_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetHttpDate"], - self.target_http_date, - ) + serializer.write_timestamp(members[5], self.target_http_date) if self.target_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetDateTime"], - self.target_date_time, - ) + serializer.write_timestamp(members[6], self.target_date_time) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7182,54 +6246,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members[ - "memberEpochSeconds" - ] - ) + kwargs["member_epoch_seconds"] = de.read_timestamp(members[0]) case 1: - kwargs["member_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberHttpDate"] - ) + kwargs["member_http_date"] = de.read_timestamp(members[1]) case 2: - kwargs["member_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["memberDateTime"] - ) + kwargs["member_date_time"] = de.read_timestamp(members[2]) case 3: - kwargs["default_format"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["defaultFormat"] - ) + kwargs["default_format"] = de.read_timestamp(members[3]) case 4: - kwargs["target_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members[ - "targetEpochSeconds" - ] - ) + kwargs["target_epoch_seconds"] = de.read_timestamp(members[4]) case 5: - kwargs["target_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetHttpDate"] - ) + kwargs["target_http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["target_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT.members["targetDateTime"] - ) + kwargs["target_date_time"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7262,50 +6308,30 @@ class TimestampFormatHeadersOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT).members_by_index if self.member_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["memberEpochSeconds"], - self.member_epoch_seconds, - ) + serializer.write_timestamp(members[0], self.member_epoch_seconds) if self.member_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["memberHttpDate"], - self.member_http_date, - ) + serializer.write_timestamp(members[1], self.member_http_date) if self.member_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["memberDateTime"], - self.member_date_time, - ) + serializer.write_timestamp(members[2], self.member_date_time) if self.default_format is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["defaultFormat"], - self.default_format, - ) + serializer.write_timestamp(members[3], self.default_format) if self.target_epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["targetEpochSeconds"], - self.target_epoch_seconds, - ) + serializer.write_timestamp(members[4], self.target_epoch_seconds) if self.target_http_date is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["targetHttpDate"], - self.target_http_date, - ) + serializer.write_timestamp(members[5], self.target_http_date) if self.target_date_time is not None: - serializer.write_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["targetDateTime"], - self.target_date_time, - ) + serializer.write_timestamp(members[6], self.target_date_time) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7314,74 +6340,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "memberEpochSeconds" - ] - ) + kwargs["member_epoch_seconds"] = de.read_timestamp(members[0]) case 1: - kwargs["member_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "memberHttpDate" - ] - ) + kwargs["member_http_date"] = de.read_timestamp(members[1]) case 2: - kwargs["member_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "memberDateTime" - ] - ) + kwargs["member_date_time"] = de.read_timestamp(members[2]) case 3: - kwargs["default_format"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members["defaultFormat"] - ) + kwargs["default_format"] = de.read_timestamp(members[3]) case 4: - kwargs["target_epoch_seconds"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "targetEpochSeconds" - ] - ) + kwargs["target_epoch_seconds"] = de.read_timestamp(members[4]) case 5: - kwargs["target_http_date"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "targetHttpDate" - ] - ) + kwargs["target_http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["target_date_time"] = de.read_timestamp( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT.members[ - "targetDateTime" - ] - ) + kwargs["target_date_time"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs TIMESTAMP_FORMAT_HEADERS = APIOperation( input=TimestampFormatHeadersInput, output=TimestampFormatHeadersOutput, - schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS, - input_schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS_INPUT, - output_schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS_OUTPUT, + static_schema=_SCHEMA_TIMESTAMP_FORMAT_HEADERS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7394,18 +6391,15 @@ class XmlAttributesInput: attr: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_INPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_INPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.attr is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_INPUT.members["attr"], self.attr - ) + serializer.write_string(members[1], self.attr) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7414,23 +6408,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_INPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["attr"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_INPUT.members["attr"] - ) + kwargs["attr"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ATTRIBUTES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7453,18 +6445,15 @@ class XmlAttributesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_OUTPUT).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_OUTPUT.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.attr is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_OUTPUT.members["attr"], self.attr - ) + serializer.write_string(members[1], self.attr) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7473,35 +6462,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_OUTPUT.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["attr"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_OUTPUT.members["attr"] - ) + kwargs["attr"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ATTRIBUTES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_ATTRIBUTES = APIOperation( input=XmlAttributesInput, output=XmlAttributesOutput, - schema=_SCHEMA_XML_ATTRIBUTES, - input_schema=_SCHEMA_XML_ATTRIBUTES_INPUT, - output_schema=_SCHEMA_XML_ATTRIBUTES_OUTPUT, + static_schema=_SCHEMA_XML_ATTRIBUTES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7516,26 +6500,22 @@ class XmlAttributesInMiddlePayloadRequest: baz: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST, self) + serializer.write_struct( + hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.attr is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST.members["attr"], - self.attr, - ) + serializer.write_string(members[1], self.attr) if self.baz is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST.members["baz"], - self.baz, - ) + serializer.write_string(members[2], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7544,30 +6524,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["attr"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST.members["attr"] - ) + kwargs["attr"] = de.read_string(members[1]) case 2: - kwargs["baz"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST.members["baz"] - ) + kwargs["baz"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7578,13 +6552,12 @@ class XmlAttributesInMiddleInput: payload: XmlAttributesInMiddlePayloadRequest | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT).members_by_index if self.payload is not None: - serializer.write_struct( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT.members["payload"], self.payload - ) + serializer.write_struct(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7593,20 +6566,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["payload"] = XmlAttributesInMiddlePayloadRequest.deserialize( de ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7621,26 +6594,22 @@ class XmlAttributesInMiddlePayloadResponse: baz: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE, self) + serializer.write_struct( + hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE.members["foo"], - self.foo, - ) + serializer.write_string(members[0], self.foo) if self.attr is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE.members["attr"], - self.attr, - ) + serializer.write_string(members[1], self.attr) if self.baz is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE.members["baz"], - self.baz, - ) + serializer.write_string(members[2], self.baz) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7649,32 +6618,24 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["attr"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE.members[ - "attr" - ] - ) + kwargs["attr"] = de.read_string(members[1]) case 2: - kwargs["baz"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE.members["baz"] - ) + kwargs["baz"] = de.read_string(members[2]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7695,13 +6656,12 @@ class XmlAttributesInMiddleOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT).members_by_index if self.payload is not None: - serializer.write_struct( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT.members["payload"], self.payload - ) + serializer.write_struct(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7710,32 +6670,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["payload"] = ( XmlAttributesInMiddlePayloadResponse.deserialize(de) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_ATTRIBUTES_IN_MIDDLE = APIOperation( input=XmlAttributesInMiddleInput, output=XmlAttributesInMiddleOutput, - schema=_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE, - input_schema=_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_INPUT, - output_schema=_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE_OUTPUT, + static_schema=_SCHEMA_XML_ATTRIBUTES_IN_MIDDLE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7748,18 +6705,15 @@ class XmlAttributesPayloadRequest: attr: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.attr is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST.members["attr"], self.attr - ) + serializer.write_string(members[1], self.attr) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7768,25 +6722,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["attr"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST.members["attr"] - ) + kwargs["attr"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_REQUEST, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7797,13 +6747,12 @@ class XmlAttributesOnPayloadInput: payload: XmlAttributesPayloadRequest | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT).members_by_index if self.payload is not None: - serializer.write_struct( - _SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT.members["payload"], self.payload - ) + serializer.write_struct(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7812,18 +6761,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["payload"] = XmlAttributesPayloadRequest.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7836,18 +6785,15 @@ class XmlAttributesPayloadResponse: attr: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.attr is not None: - serializer.write_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE.members["attr"], self.attr - ) + serializer.write_string(members[1], self.attr) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7856,25 +6802,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["attr"] = de.read_string( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE.members["attr"] - ) + kwargs["attr"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_PAYLOAD_RESPONSE, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7895,14 +6837,12 @@ class XmlAttributesOnPayloadOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT).members_by_index if self.payload is not None: - serializer.write_struct( - _SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT.members["payload"], - self.payload, - ) + serializer.write_struct(members[0], self.payload) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7911,30 +6851,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["payload"] = XmlAttributesPayloadResponse.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_ATTRIBUTES_ON_PAYLOAD = APIOperation( input=XmlAttributesOnPayloadInput, output=XmlAttributesOnPayloadOutput, - schema=_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD, - input_schema=_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_INPUT, - output_schema=_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT, + static_schema=_SCHEMA_XML_ATTRIBUTES_ON_PAYLOAD, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -7945,11 +6882,12 @@ class XmlBlobsInput: data: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_BLOBS_INPUT).members_by_index if self.data is not None: - serializer.write_blob(_SCHEMA_XML_BLOBS_INPUT.members["data"], self.data) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -7958,18 +6896,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_BLOBS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_BLOBS_INPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -7990,11 +6928,12 @@ class XmlBlobsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_BLOBS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_BLOBS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_BLOBS_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob(_SCHEMA_XML_BLOBS_OUTPUT.members["data"], self.data) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8003,30 +6942,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_BLOBS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_BLOBS_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_BLOBS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_BLOBS = APIOperation( input=XmlBlobsInput, output=XmlBlobsOutput, - schema=_SCHEMA_XML_BLOBS, - input_schema=_SCHEMA_XML_BLOBS_INPUT, - output_schema=_SCHEMA_XML_BLOBS_OUTPUT, + static_schema=_SCHEMA_XML_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -8037,13 +6973,12 @@ class XmlEmptyBlobsInput: data: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_BLOBS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT).members_by_index if self.data is not None: - serializer.write_blob( - _SCHEMA_XML_EMPTY_BLOBS_INPUT.members["data"], self.data - ) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8052,18 +6987,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_BLOBS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_EMPTY_BLOBS_INPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_BLOBS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8084,13 +7019,12 @@ class XmlEmptyBlobsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT).members_by_index if self.data is not None: - serializer.write_blob( - _SCHEMA_XML_EMPTY_BLOBS_OUTPUT.members["data"], self.data - ) + serializer.write_blob(members[0], self.data) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8099,30 +7033,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["data"] = de.read_blob( - _SCHEMA_XML_EMPTY_BLOBS_OUTPUT.members["data"] - ) + kwargs["data"] = de.read_blob(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_BLOBS = APIOperation( input=XmlEmptyBlobsInput, output=XmlEmptyBlobsOutput, - schema=_SCHEMA_XML_EMPTY_BLOBS, - input_schema=_SCHEMA_XML_EMPTY_BLOBS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_BLOBS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_BLOBS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -8135,14 +7066,15 @@ class StructureListMember: b: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER).members_by_index if self.a is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["a"], self.a) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["b"], self.b) + serializer.write_string(members[1], self.b) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8151,30 +7083,28 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_structure_list( serializer: ShapeSerializer, schema: Schema, value: list[StructureListMember] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -8199,7 +7129,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_nested_string_list( serializer: ShapeSerializer, schema: Schema, value: list[list[str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_string_list(ls, member_schema, e) @@ -8209,7 +7139,7 @@ def _deserialize_nested_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[list[str]]: result: list[list[str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -8258,114 +7188,65 @@ class XmlEmptyListsInput: flattened_structure_list: list[StructureListMember] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members[ - "flattenedListWithMemberNamespace" - ], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedListWithNamespace"], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) if self.flattened_structure_list is not None: _serialize_structure_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedStructureList"], - self.flattened_structure_list, + serializer, members[14], self.flattened_structure_list ) @classmethod @@ -8375,99 +7256,80 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["renamedListMembers"] + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_EMPTY_LISTS_INPUT.members["structureList"] + de, members[13] ) case 14: kwargs["flattened_structure_list"] = _deserialize_structure_list( - de, - _SCHEMA_XML_EMPTY_LISTS_INPUT.members["flattenedStructureList"], + de, members[14] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8517,114 +7379,65 @@ class XmlEmptyListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedListWithNamespace"], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) if self.flattened_structure_list is not None: _serialize_structure_list( - serializer, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedStructureList"], - self.flattened_structure_list, + serializer, members[14], self.flattened_structure_list ) @classmethod @@ -8634,113 +7447,89 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["renamedListMembers"] + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members["structureList"] + de, members[13] ) case 14: kwargs["flattened_structure_list"] = _deserialize_structure_list( - de, - _SCHEMA_XML_EMPTY_LISTS_OUTPUT.members[ - "flattenedStructureList" - ], + de, members[14] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_LISTS = APIOperation( input=XmlEmptyListsInput, output=XmlEmptyListsOutput, - schema=_SCHEMA_XML_EMPTY_LISTS, - input_schema=_SCHEMA_XML_EMPTY_LISTS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_LISTS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -8751,11 +7540,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8764,16 +7554,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8781,7 +7573,7 @@ def _serialize_xml_maps_input_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -8790,7 +7582,7 @@ def _deserialize_xml_maps_input_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -8810,13 +7602,12 @@ class XmlEmptyMapsInput: my_map: dict[str, GreetingStruct] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_MAPS_INPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_input_output_map( - serializer, _SCHEMA_XML_EMPTY_MAPS_INPUT.members["myMap"], self.my_map - ) + _serialize_xml_maps_input_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8825,18 +7616,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_input_output_map( - de, _SCHEMA_XML_EMPTY_MAPS_INPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8857,13 +7650,12 @@ class XmlEmptyMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_MAPS_OUTPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_input_output_map( - serializer, _SCHEMA_XML_EMPTY_MAPS_OUTPUT.members["myMap"], self.my_map - ) + _serialize_xml_maps_input_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8872,30 +7664,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_input_output_map( - de, _SCHEMA_XML_EMPTY_MAPS_OUTPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_MAPS = APIOperation( input=XmlEmptyMapsInput, output=XmlEmptyMapsOutput, - schema=_SCHEMA_XML_EMPTY_MAPS, - input_schema=_SCHEMA_XML_EMPTY_MAPS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_MAPS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -8906,14 +7697,12 @@ class XmlEmptyStringsInput: empty_string: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_STRINGS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_STRINGS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_STRINGS_INPUT).members_by_index if self.empty_string is not None: - serializer.write_string( - _SCHEMA_XML_EMPTY_STRINGS_INPUT.members["emptyString"], - self.empty_string, - ) + serializer.write_string(members[0], self.empty_string) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8922,18 +7711,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_STRINGS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["empty_string"] = de.read_string( - _SCHEMA_XML_EMPTY_STRINGS_INPUT.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_STRINGS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -8954,14 +7743,12 @@ class XmlEmptyStringsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_EMPTY_STRINGS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_EMPTY_STRINGS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_EMPTY_STRINGS_OUTPUT).members_by_index if self.empty_string is not None: - serializer.write_string( - _SCHEMA_XML_EMPTY_STRINGS_OUTPUT.members["emptyString"], - self.empty_string, - ) + serializer.write_string(members[0], self.empty_string) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -8970,37 +7757,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_EMPTY_STRINGS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["empty_string"] = de.read_string( - _SCHEMA_XML_EMPTY_STRINGS_OUTPUT.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_EMPTY_STRINGS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_EMPTY_STRINGS = APIOperation( input=XmlEmptyStringsInput, output=XmlEmptyStringsOutput, - schema=_SCHEMA_XML_EMPTY_STRINGS, - input_schema=_SCHEMA_XML_EMPTY_STRINGS_INPUT, - output_schema=_SCHEMA_XML_EMPTY_STRINGS_OUTPUT, + static_schema=_SCHEMA_XML_EMPTY_STRINGS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_foo_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -9010,7 +7794,7 @@ def _deserialize_foo_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -9040,44 +7824,27 @@ class XmlEnumsInput: foo_enum_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ENUMS_INPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_INPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_INPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_INPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_ENUMS_INPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_XML_ENUMS_INPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_XML_ENUMS_INPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9086,43 +7853,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ENUMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_INPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_INPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_INPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_ENUMS_INPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_XML_ENUMS_INPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_XML_ENUMS_INPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9153,44 +7910,27 @@ class XmlEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_ENUMS_OUTPUT).members_by_index if self.foo_enum1 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum1"], self.foo_enum1 - ) + serializer.write_string(members[0], self.foo_enum1) if self.foo_enum2 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum2"], self.foo_enum2 - ) + serializer.write_string(members[1], self.foo_enum2) if self.foo_enum3 is not None: - serializer.write_string( - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum3"], self.foo_enum3 - ) + serializer.write_string(members[2], self.foo_enum3) if self.foo_enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumList"], - self.foo_enum_list, - ) + _serialize_foo_enum_list(serializer, members[3], self.foo_enum_list) if self.foo_enum_set is not None: - _serialize_foo_enum_set( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumSet"], - self.foo_enum_set, - ) + _serialize_foo_enum_set(serializer, members[4], self.foo_enum_set) if self.foo_enum_map is not None: - _serialize_foo_enum_map( - serializer, - _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumMap"], - self.foo_enum_map, - ) + _serialize_foo_enum_map(serializer, members[5], self.foo_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9199,55 +7939,42 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo_enum1"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum1"]) - ) + kwargs["foo_enum1"] = FooEnum(de.read_string(members[0])) case 1: - kwargs["foo_enum2"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum2"]) - ) + kwargs["foo_enum2"] = FooEnum(de.read_string(members[1])) case 2: - kwargs["foo_enum3"] = FooEnum( - de.read_string(_SCHEMA_XML_ENUMS_OUTPUT.members["fooEnum3"]) - ) + kwargs["foo_enum3"] = FooEnum(de.read_string(members[2])) case 3: - kwargs["foo_enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumList"] - ) + kwargs["foo_enum_list"] = _deserialize_foo_enum_list(de, members[3]) case 4: - kwargs["foo_enum_set"] = _deserialize_foo_enum_set( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumSet"] - ) + kwargs["foo_enum_set"] = _deserialize_foo_enum_set(de, members[4]) case 5: - kwargs["foo_enum_map"] = _deserialize_foo_enum_map( - de, _SCHEMA_XML_ENUMS_OUTPUT.members["fooEnumMap"] - ) + kwargs["foo_enum_map"] = _deserialize_foo_enum_map(de, members[5]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_ENUMS = APIOperation( input=XmlEnumsInput, output=XmlEnumsOutput, - schema=_SCHEMA_XML_ENUMS, - input_schema=_SCHEMA_XML_ENUMS_INPUT, - output_schema=_SCHEMA_XML_ENUMS_OUTPUT, + static_schema=_SCHEMA_XML_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9255,7 +7982,7 @@ def _serialize_integer_enum_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -9264,7 +7991,7 @@ def _deserialize_integer_enum_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -9280,7 +8007,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_integer_enum_set( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -9290,7 +8017,7 @@ def _deserialize_integer_enum_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -9320,44 +8047,27 @@ class XmlIntEnumsInput: int_enum_map: dict[str, int] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_INT_ENUMS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_INT_ENUMS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_INT_ENUMS_INPUT).members_by_index if self.int_enum1 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnum1"], self.int_enum1 - ) + serializer.write_integer(members[0], self.int_enum1) if self.int_enum2 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnum2"], self.int_enum2 - ) + serializer.write_integer(members[1], self.int_enum2) if self.int_enum3 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnum3"], self.int_enum3 - ) + serializer.write_integer(members[2], self.int_enum3) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.int_enum_list) if self.int_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnumSet"], - self.int_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.int_enum_set) if self.int_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnumMap"], - self.int_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.int_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9366,43 +8076,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_INT_ENUMS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_enum1"] = IntegerEnum( - de.read_integer(_SCHEMA_XML_INT_ENUMS_INPUT.members["intEnum1"]) - ) + kwargs["int_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["int_enum2"] = IntegerEnum( - de.read_integer(_SCHEMA_XML_INT_ENUMS_INPUT.members["intEnum2"]) - ) + kwargs["int_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["int_enum3"] = IntegerEnum( - de.read_integer(_SCHEMA_XML_INT_ENUMS_INPUT.members["intEnum3"]) - ) + kwargs["int_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnumList"] + de, members[3] ) case 4: kwargs["int_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnumSet"] + de, members[4] ) case 5: kwargs["int_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_XML_INT_ENUMS_INPUT.members["intEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_INT_ENUMS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9433,44 +8139,27 @@ class XmlIntEnumsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_INT_ENUMS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT).members_by_index if self.int_enum1 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum1"], self.int_enum1 - ) + serializer.write_integer(members[0], self.int_enum1) if self.int_enum2 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum2"], self.int_enum2 - ) + serializer.write_integer(members[1], self.int_enum2) if self.int_enum3 is not None: - serializer.write_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum3"], self.int_enum3 - ) + serializer.write_integer(members[2], self.int_enum3) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[3], self.int_enum_list) if self.int_enum_set is not None: - _serialize_integer_enum_set( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumSet"], - self.int_enum_set, - ) + _serialize_integer_enum_set(serializer, members[4], self.int_enum_set) if self.int_enum_map is not None: - _serialize_integer_enum_map( - serializer, - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumMap"], - self.int_enum_map, - ) + _serialize_integer_enum_map(serializer, members[5], self.int_enum_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -9479,61 +8168,48 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_INT_ENUMS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["int_enum1"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum1"] - ) - ) + kwargs["int_enum1"] = IntegerEnum(de.read_integer(members[0])) case 1: - kwargs["int_enum2"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum2"] - ) - ) + kwargs["int_enum2"] = IntegerEnum(de.read_integer(members[1])) case 2: - kwargs["int_enum3"] = IntegerEnum( - de.read_integer( - _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnum3"] - ) - ) + kwargs["int_enum3"] = IntegerEnum(de.read_integer(members[2])) case 3: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumList"] + de, members[3] ) case 4: kwargs["int_enum_set"] = _deserialize_integer_enum_set( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumSet"] + de, members[4] ) case 5: kwargs["int_enum_map"] = _deserialize_integer_enum_map( - de, _SCHEMA_XML_INT_ENUMS_OUTPUT.members["intEnumMap"] + de, members[5] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_INT_ENUMS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_INT_ENUMS = APIOperation( input=XmlIntEnumsInput, output=XmlIntEnumsOutput, - schema=_SCHEMA_XML_INT_ENUMS, - input_schema=_SCHEMA_XML_INT_ENUMS_INPUT, - output_schema=_SCHEMA_XML_INT_ENUMS_OUTPUT, + static_schema=_SCHEMA_XML_INT_ENUMS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -9573,110 +8249,65 @@ class XmlListsInput: flattened_structure_list: list[StructureListMember] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_LISTS_INPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, _SCHEMA_XML_LISTS_INPUT.members["enumList"], self.enum_list - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["flattenedListWithMemberNamespace"], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["flattenedListWithNamespace"], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) if self.flattened_structure_list is not None: _serialize_structure_list( - serializer, - _SCHEMA_XML_LISTS_INPUT.members["flattenedStructureList"], - self.flattened_structure_list, + serializer, members[14], self.flattened_structure_list ) @classmethod @@ -9686,98 +8317,80 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_LISTS_INPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_LISTS_INPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_LISTS_INPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_LISTS_INPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_LISTS_INPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_LISTS_INPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_LISTS_INPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_XML_LISTS_INPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_INPUT.members["renamedListMembers"] + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_INPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_INPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_LISTS_INPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_LISTS_INPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_LISTS_INPUT.members["structureList"] + de, members[13] ) case 14: kwargs["flattened_structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_LISTS_INPUT.members["flattenedStructureList"] + de, members[14] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -9827,110 +8440,65 @@ class XmlListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_LISTS_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, _SCHEMA_XML_LISTS_OUTPUT.members["enumList"], self.enum_list - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.renamed_list_members is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["renamedListMembers"], - self.renamed_list_members, + serializer, members[8], self.renamed_list_members ) if self.flattened_list is not None: - _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["flattenedList"], - self.flattened_list, - ) + _serialize_renamed_list_members(serializer, members[9], self.flattened_list) if self.flattened_list2 is not None: _serialize_renamed_list_members( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["flattenedList2"], - self.flattened_list2, + serializer, members[10], self.flattened_list2 ) if self.flattened_list_with_member_namespace is not None: _serialize_list_with_member_namespace( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["flattenedListWithMemberNamespace"], - self.flattened_list_with_member_namespace, + serializer, members[11], self.flattened_list_with_member_namespace ) if self.flattened_list_with_namespace is not None: _serialize_list_with_namespace( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["flattenedListWithNamespace"], - self.flattened_list_with_namespace, + serializer, members[12], self.flattened_list_with_namespace ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[13], self.structure_list) if self.flattened_structure_list is not None: _serialize_structure_list( - serializer, - _SCHEMA_XML_LISTS_OUTPUT.members["flattenedStructureList"], - self.flattened_structure_list, + serializer, members[14], self.flattened_structure_list ) @classmethod @@ -9940,110 +8508,89 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_XML_LISTS_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["renamed_list_members"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OUTPUT.members["renamedListMembers"] + de, members[8] ) case 9: kwargs["flattened_list"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OUTPUT.members["flattenedList"] + de, members[9] ) case 10: kwargs["flattened_list2"] = _deserialize_renamed_list_members( - de, _SCHEMA_XML_LISTS_OUTPUT.members["flattenedList2"] + de, members[10] ) case 11: kwargs["flattened_list_with_member_namespace"] = ( - _deserialize_list_with_member_namespace( - de, - _SCHEMA_XML_LISTS_OUTPUT.members[ - "flattenedListWithMemberNamespace" - ], - ) + _deserialize_list_with_member_namespace(de, members[11]) ) case 12: kwargs["flattened_list_with_namespace"] = ( - _deserialize_list_with_namespace( - de, - _SCHEMA_XML_LISTS_OUTPUT.members[ - "flattenedListWithNamespace" - ], - ) + _deserialize_list_with_namespace(de, members[12]) ) case 13: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["structureList"] + de, members[13] ) case 14: kwargs["flattened_structure_list"] = _deserialize_structure_list( - de, _SCHEMA_XML_LISTS_OUTPUT.members["flattenedStructureList"] + de, members[14] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_LISTS = APIOperation( input=XmlListsInput, output=XmlListsOutput, - schema=_SCHEMA_XML_LISTS, - input_schema=_SCHEMA_XML_LISTS_INPUT, - output_schema=_SCHEMA_XML_LISTS_OUTPUT, + static_schema=_SCHEMA_XML_LISTS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10054,13 +8601,12 @@ class XmlMapsInput: my_map: dict[str, GreetingStruct] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAPS_INPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_input_output_map( - serializer, _SCHEMA_XML_MAPS_INPUT.members["myMap"], self.my_map - ) + _serialize_xml_maps_input_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10069,18 +8615,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_input_output_map( - de, _SCHEMA_XML_MAPS_INPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10101,13 +8649,12 @@ class XmlMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAPS_OUTPUT).members_by_index if self.my_map is not None: - _serialize_xml_maps_input_output_map( - serializer, _SCHEMA_XML_MAPS_OUTPUT.members["myMap"], self.my_map - ) + _serialize_xml_maps_input_output_map(serializer, members[0], self.my_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10116,30 +8663,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_input_output_map( - de, _SCHEMA_XML_MAPS_OUTPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_MAPS = APIOperation( input=XmlMapsInput, output=XmlMapsOutput, - schema=_SCHEMA_XML_MAPS, - input_schema=_SCHEMA_XML_MAPS_INPUT, - output_schema=_SCHEMA_XML_MAPS_OUTPUT, + static_schema=_SCHEMA_XML_MAPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10147,7 +8693,7 @@ def _serialize_xml_maps_xml_name_input_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -10156,7 +8702,7 @@ def _deserialize_xml_maps_xml_name_input_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -10176,14 +8722,13 @@ class XmlMapsXmlNameInput: my_map: dict[str, GreetingStruct] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_XML_NAME_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_XML_NAME_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAPS_XML_NAME_INPUT).members_by_index if self.my_map is not None: _serialize_xml_maps_xml_name_input_output_map( - serializer, - _SCHEMA_XML_MAPS_XML_NAME_INPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -10193,18 +8738,20 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_XML_NAME_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_xml_name_input_output_map( - de, _SCHEMA_XML_MAPS_XML_NAME_INPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_XML_NAME_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10225,14 +8772,13 @@ class XmlMapsXmlNameOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT).members_by_index if self.my_map is not None: _serialize_xml_maps_xml_name_input_output_map( - serializer, - _SCHEMA_XML_MAPS_XML_NAME_OUTPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -10242,30 +8788,29 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = _deserialize_xml_maps_xml_name_input_output_map( - de, _SCHEMA_XML_MAPS_XML_NAME_OUTPUT.members["myMap"] + de, members[0] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_MAPS_XML_NAME_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_MAPS_XML_NAME = APIOperation( input=XmlMapsXmlNameInput, output=XmlMapsXmlNameOutput, - schema=_SCHEMA_XML_MAPS_XML_NAME, - input_schema=_SCHEMA_XML_MAPS_XML_NAME_INPUT, - output_schema=_SCHEMA_XML_MAPS_XML_NAME_OUTPUT, + static_schema=_SCHEMA_XML_MAPS_XML_NAME, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10273,7 +8818,7 @@ def _serialize_xml_map_with_xml_namespace_input_output_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -10282,7 +8827,7 @@ def _deserialize_xml_map_with_xml_namespace_input_output_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -10302,14 +8847,13 @@ class XmlMapWithXmlNamespaceInput: my_map: dict[str, str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT).members_by_index if self.my_map is not None: _serialize_xml_map_with_xml_namespace_input_output_map( - serializer, - _SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -10319,23 +8863,22 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_xml_map_with_xml_namespace_input_output_map( - de, - _SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT.members["myMap"], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10356,14 +8899,15 @@ class XmlMapWithXmlNamespaceOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, self) + serializer.write_struct( + hydrate(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT).members_by_index if self.my_map is not None: _serialize_xml_map_with_xml_namespace_input_output_map( - serializer, - _SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT.members["myMap"], - self.my_map, + serializer, members[0], self.my_map ) @classmethod @@ -10373,42 +8917,38 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["my_map"] = ( _deserialize_xml_map_with_xml_namespace_input_output_map( - de, - _SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT.members["myMap"], + de, members[0] ) ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_MAP_WITH_XML_NAMESPACE = APIOperation( input=XmlMapWithXmlNamespaceInput, output=XmlMapWithXmlNamespaceOutput, - schema=_SCHEMA_XML_MAP_WITH_XML_NAMESPACE, - input_schema=_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_INPUT, - output_schema=_SCHEMA_XML_MAP_WITH_XML_NAMESPACE_OUTPUT, + static_schema=_SCHEMA_XML_MAP_WITH_XML_NAMESPACE, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) def _serialize_xml_namespaced_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -10418,7 +8958,7 @@ def _deserialize_xml_namespaced_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -10440,18 +8980,15 @@ class XmlNamespaceNested: values: list[str] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACE_NESTED, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACE_NESTED), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACE_NESTED).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_XML_NAMESPACE_NESTED.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.values is not None: - _serialize_xml_namespaced_list( - serializer, _SCHEMA_XML_NAMESPACE_NESTED.members["values"], self.values - ) + _serialize_xml_namespaced_list(serializer, members[1], self.values) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10460,23 +8997,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACE_NESTED) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_XML_NAMESPACE_NESTED.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: - kwargs["values"] = _deserialize_xml_namespaced_list( - de, _SCHEMA_XML_NAMESPACE_NESTED.members["values"] - ) + kwargs["values"] = _deserialize_xml_namespaced_list(de, members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACE_NESTED, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10487,13 +9022,12 @@ class XmlNamespacesInput: nested: XmlNamespaceNested | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACES_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_XML_NAMESPACES_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10502,16 +9036,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = XmlNamespaceNested.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10532,13 +9068,12 @@ class XmlNamespacesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NAMESPACES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_XML_NAMESPACES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10547,28 +9082,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NAMESPACES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = XmlNamespaceNested.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NAMESPACES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_NAMESPACES = APIOperation( input=XmlNamespacesInput, output=XmlNamespacesOutput, - schema=_SCHEMA_XML_NAMESPACES, - input_schema=_SCHEMA_XML_NAMESPACES_INPUT, - output_schema=_SCHEMA_XML_NAMESPACES_OUTPUT, + static_schema=_SCHEMA_XML_NAMESPACES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10591,46 +9125,30 @@ class XmlTimestampsInput: http_date_on_target: datetime | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_TIMESTAMPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT).members_by_index if self.normal is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["normal"], self.normal - ) + serializer.write_timestamp(members[0], self.normal) if self.date_time is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["dateTime"], self.date_time - ) + serializer.write_timestamp(members[1], self.date_time) if self.date_time_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["dateTimeOnTarget"], - self.date_time_on_target, - ) + serializer.write_timestamp(members[2], self.date_time_on_target) if self.epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["epochSeconds"], self.epoch_seconds - ) + serializer.write_timestamp(members[3], self.epoch_seconds) if self.epoch_seconds_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["epochSecondsOnTarget"], - self.epoch_seconds_on_target, - ) + serializer.write_timestamp(members[4], self.epoch_seconds_on_target) if self.http_date is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["httpDate"], self.http_date - ) + serializer.write_timestamp(members[5], self.http_date) if self.http_date_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["httpDateOnTarget"], - self.http_date_on_target, - ) + serializer.write_timestamp(members[6], self.http_date_on_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10639,48 +9157,36 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_TIMESTAMPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["normal"] - ) + kwargs["normal"] = de.read_timestamp(members[0]) case 1: - kwargs["date_time"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["dateTime"] - ) + kwargs["date_time"] = de.read_timestamp(members[1]) case 2: - kwargs["date_time_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["dateTimeOnTarget"] - ) + kwargs["date_time_on_target"] = de.read_timestamp(members[2]) case 3: - kwargs["epoch_seconds"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["epochSeconds"] - ) + kwargs["epoch_seconds"] = de.read_timestamp(members[3]) case 4: - kwargs["epoch_seconds_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["epochSecondsOnTarget"] - ) + kwargs["epoch_seconds_on_target"] = de.read_timestamp(members[4]) case 5: - kwargs["http_date"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["httpDate"] - ) + kwargs["http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["http_date_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_INPUT.members["httpDateOnTarget"] - ) + kwargs["http_date_on_target"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_TIMESTAMPS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10713,47 +9219,30 @@ class XmlTimestampsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_TIMESTAMPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT).members_by_index if self.normal is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["normal"], self.normal - ) + serializer.write_timestamp(members[0], self.normal) if self.date_time is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTime"], self.date_time - ) + serializer.write_timestamp(members[1], self.date_time) if self.date_time_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"], - self.date_time_on_target, - ) + serializer.write_timestamp(members[2], self.date_time_on_target) if self.epoch_seconds is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSeconds"], - self.epoch_seconds, - ) + serializer.write_timestamp(members[3], self.epoch_seconds) if self.epoch_seconds_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"], - self.epoch_seconds_on_target, - ) + serializer.write_timestamp(members[4], self.epoch_seconds_on_target) if self.http_date is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDate"], self.http_date - ) + serializer.write_timestamp(members[5], self.http_date) if self.http_date_on_target is not None: - serializer.write_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"], - self.http_date_on_target, - ) + serializer.write_timestamp(members[6], self.http_date_on_target) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10762,60 +9251,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_TIMESTAMPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["normal"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["normal"] - ) + kwargs["normal"] = de.read_timestamp(members[0]) case 1: - kwargs["date_time"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTime"] - ) + kwargs["date_time"] = de.read_timestamp(members[1]) case 2: - kwargs["date_time_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["dateTimeOnTarget"] - ) + kwargs["date_time_on_target"] = de.read_timestamp(members[2]) case 3: - kwargs["epoch_seconds"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSeconds"] - ) + kwargs["epoch_seconds"] = de.read_timestamp(members[3]) case 4: - kwargs["epoch_seconds_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["epochSecondsOnTarget"] - ) + kwargs["epoch_seconds_on_target"] = de.read_timestamp(members[4]) case 5: - kwargs["http_date"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDate"] - ) + kwargs["http_date"] = de.read_timestamp(members[5]) case 6: - kwargs["http_date_on_target"] = de.read_timestamp( - _SCHEMA_XML_TIMESTAMPS_OUTPUT.members["httpDateOnTarget"] - ) + kwargs["http_date_on_target"] = de.read_timestamp(members[6]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_TIMESTAMPS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_TIMESTAMPS = APIOperation( input=XmlTimestampsInput, output=XmlTimestampsOutput, - schema=_SCHEMA_XML_TIMESTAMPS, - input_schema=_SCHEMA_XML_TIMESTAMPS_INPUT, - output_schema=_SCHEMA_XML_TIMESTAMPS_OUTPUT, + static_schema=_SCHEMA_XML_TIMESTAMPS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) @@ -10840,52 +9314,33 @@ class XmlNestedUnionStruct: double_value: float | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_NESTED_UNION_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_NESTED_UNION_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_NESTED_UNION_STRUCT).members_by_index if self.string_value is not None: - serializer.write_string( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[0], self.string_value) if self.boolean_value is not None: - serializer.write_boolean( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["booleanValue"], - self.boolean_value, - ) + serializer.write_boolean(members[1], self.boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["byteValue"], self.byte_value - ) + serializer.write_byte(members[2], self.byte_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["shortValue"], self.short_value - ) + serializer.write_short(members[3], self.short_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[4], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["longValue"], self.long_value - ) + serializer.write_long(members[5], self.long_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["floatValue"], self.float_value - ) + serializer.write_float(members[6], self.float_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[7], self.double_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -10894,53 +9349,39 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_NESTED_UNION_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_value"] = de.read_string( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[0]) case 1: - kwargs["boolean_value"] = de.read_boolean( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["booleanValue"] - ) + kwargs["boolean_value"] = de.read_boolean(members[1]) case 2: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[2]) case 3: - kwargs["short_value"] = de.read_short( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[3]) case 4: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[4]) case 5: - kwargs["long_value"] = de.read_long( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[5]) case 6: - kwargs["float_value"] = de.read_float( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[6]) case 7: - kwargs["double_value"] = de.read_double( - _SCHEMA_XML_NESTED_UNION_STRUCT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[7]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_NESTED_UNION_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -10949,20 +9390,16 @@ class XmlUnionShapeStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_XML_UNION_SHAPE.members["stringValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_XML_UNION_SHAPE.members["stringValue"] - ) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -10970,20 +9407,16 @@ class XmlUnionShapeBooleanValue: value: bool def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_boolean( - _SCHEMA_XML_UNION_SHAPE.members["booleanValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_boolean(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_boolean( - _SCHEMA_XML_UNION_SHAPE.members["booleanValue"] - ) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_boolean(members[1])) @dataclass @@ -10991,16 +9424,16 @@ class XmlUnionShapeByteValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_byte(_SCHEMA_XML_UNION_SHAPE.members["byteValue"], self.value) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_byte(members[2], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_byte(_SCHEMA_XML_UNION_SHAPE.members["byteValue"]) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_byte(members[2])) @dataclass @@ -11008,18 +9441,16 @@ class XmlUnionShapeShortValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_short( - _SCHEMA_XML_UNION_SHAPE.members["shortValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_short(members[3], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_short(_SCHEMA_XML_UNION_SHAPE.members["shortValue"]) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_short(members[3])) @dataclass @@ -11027,20 +9458,16 @@ class XmlUnionShapeIntegerValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_integer( - _SCHEMA_XML_UNION_SHAPE.members["integerValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_integer(members[4], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_integer( - _SCHEMA_XML_UNION_SHAPE.members["integerValue"] - ) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_integer(members[4])) @dataclass @@ -11048,16 +9475,16 @@ class XmlUnionShapeLongValue: value: int def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_long(_SCHEMA_XML_UNION_SHAPE.members["longValue"], self.value) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_long(members[5], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_long(_SCHEMA_XML_UNION_SHAPE.members["longValue"]) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_long(members[5])) @dataclass @@ -11065,18 +9492,16 @@ class XmlUnionShapeFloatValue: value: float def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_float( - _SCHEMA_XML_UNION_SHAPE.members["floatValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_float(members[6], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_float(_SCHEMA_XML_UNION_SHAPE.members["floatValue"]) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_float(members[6])) @dataclass @@ -11084,20 +9509,16 @@ class XmlUnionShapeDoubleValue: value: float def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_double( - _SCHEMA_XML_UNION_SHAPE.members["doubleValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_double(members[7], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_double( - _SCHEMA_XML_UNION_SHAPE.members["doubleValue"] - ) - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + return cls(value=deserializer.read_double(members[7])) @dataclass @@ -11105,12 +9526,11 @@ class XmlUnionShapeUnionValue: value: "XmlUnionShape" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_XML_UNION_SHAPE.members["unionValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_struct(members[8], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11122,12 +9542,11 @@ class XmlUnionShapeStructValue: value: XmlNestedUnionStruct def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNION_SHAPE, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_XML_UNION_SHAPE.members["structValue"], self.value - ) + members = hydrate(_SCHEMA_XML_UNION_SHAPE).members_by_index + serializer.write_struct(members[9], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11178,7 +9597,7 @@ class _XmlUnionShapeDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> XmlUnionShape: self._result = None - deserializer.read_struct(_SCHEMA_XML_UNION_SHAPE, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_XML_UNION_SHAPE), self._consumer) if self._result is None: raise SerializationError( @@ -11239,19 +9658,19 @@ class RecursiveShapesInputOutputNested1: nested: "RecursiveShapesInputOutputNested2 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["nested"], - self.nested, - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11260,23 +9679,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: kwargs["nested"] = RecursiveShapesInputOutputNested2.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11289,21 +9706,19 @@ class RecursiveShapesInputOutputNested2: recursive_member: "RecursiveShapesInputOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 + ).members_by_index if self.bar is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members["bar"], self.bar - ) + serializer.write_string(members[0], self.bar) if self.recursive_member is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members[ - "recursiveMember" - ], - self.recursive_member, - ) + serializer.write_struct(members[1], self.recursive_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11312,13 +9727,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bar"] = de.read_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members["bar"] - ) + kwargs["bar"] = de.read_string(members[0]) case 1: kwargs["recursive_member"] = ( @@ -11326,11 +9741,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11341,13 +9754,12 @@ class XmlUnionsInput: union_value: "XmlUnionShape | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNIONS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNIONS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_UNIONS_INPUT).members_by_index if self.union_value is not None: - serializer.write_struct( - _SCHEMA_XML_UNIONS_INPUT.members["unionValue"], self.union_value - ) + serializer.write_struct(members[0], self.union_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11356,16 +9768,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_UNIONS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["union_value"] = _XmlUnionShapeDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_UNIONS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11386,13 +9800,12 @@ class XmlUnionsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_XML_UNIONS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_XML_UNIONS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_XML_UNIONS_OUTPUT).members_by_index if self.union_value is not None: - serializer.write_struct( - _SCHEMA_XML_UNIONS_OUTPUT.members["unionValue"], self.union_value - ) + serializer.write_struct(members[0], self.union_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11401,16 +9814,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_XML_UNIONS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["union_value"] = _XmlUnionShapeDeserializer().deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_XML_UNIONS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11421,13 +9836,12 @@ class RecursiveShapesInput: nested: "RecursiveShapesInputOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11436,16 +9850,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveShapesInputOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -11466,13 +9882,12 @@ class RecursiveShapesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -11481,37 +9896,33 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveShapesInputOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_SHAPES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs XML_UNIONS = APIOperation( input=XmlUnionsInput, output=XmlUnionsOutput, - schema=_SCHEMA_XML_UNIONS, - input_schema=_SCHEMA_XML_UNIONS_INPUT, - output_schema=_SCHEMA_XML_UNIONS_OUTPUT, + static_schema=_SCHEMA_XML_UNIONS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) RECURSIVE_SHAPES = APIOperation( input=RecursiveShapesInput, output=RecursiveShapesOutput, - schema=_SCHEMA_RECURSIVE_SHAPES, - input_schema=_SCHEMA_RECURSIVE_SHAPES_INPUT, - output_schema=_SCHEMA_RECURSIVE_SHAPES_OUTPUT, + static_schema=_SCHEMA_RECURSIVE_SHAPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("aws.auth#sigv4")], - error_schemas=[], ) diff --git a/codegen-output/rpcv2-cbor/pyproject.toml b/codegen-output/rpcv2-cbor/pyproject.toml index 5b6ca1746..3d5db392f 100644 --- a/codegen-output/rpcv2-cbor/pyproject.toml +++ b/codegen-output/rpcv2-cbor/pyproject.toml @@ -53,6 +53,10 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false +reportUnknownVariableType = false +reportUnknownMemberType = false +reportUnknownArgumentType = false +reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py b/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py index 92302b87e..0e55bb61c 100644 --- a/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py +++ b/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py @@ -2,989 +2,828 @@ from types import MappingProxyType -from smithy_core.prelude import ( - BLOB, - BOOLEAN, - BYTE, - DOUBLE, - FLOAT, - INTEGER, - LONG, - SHORT, - STRING, - TIMESTAMP, - UNIT, -) -from smithy_core.schemas import Schema -from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import Trait - - -VALIDATION_EXCEPTION_FIELD = Schema.collection( - id=ShapeID("smithy.framework#ValidationExceptionField"), - members={ - "path": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "message": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - }, -) - -VALIDATION_EXCEPTION_FIELD_LIST = Schema.collection( - id=ShapeID("smithy.framework#ValidationExceptionFieldList"), - shape_type=ShapeType.LIST, - members={"member": {"target": VALIDATION_EXCEPTION_FIELD}}, -) - -VALIDATION_EXCEPTION = Schema.collection( - id=ShapeID("smithy.framework#ValidationException"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "message": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#required"))], - }, - "fieldList": {"target": VALIDATION_EXCEPTION_FIELD_LIST}, - }, -) - -CLIENT_OPTIONAL_DEFAULTS = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#ClientOptionalDefaults"), - members={ - "member": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - } - }, -) - -COMPLEX_NESTED_ERROR_DATA = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#ComplexNestedErrorData"), - members={"Foo": {"target": STRING}}, -) - -COMPLEX_ERROR = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#ComplexError"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={ - "TopLevel": {"target": STRING}, - "Nested": {"target": COMPLEX_NESTED_ERROR_DATA}, - }, -) - -TEST_ENUM = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#TestEnum"), - shape_type=ShapeType.ENUM, - members={"FOO": {"target": UNIT}, "BAR": {"target": UNIT}, "BAZ": {"target": UNIT}}, -) - -TEST_INT_ENUM = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#TestIntEnum"), - shape_type=ShapeType.INT_ENUM, - members={"ONE": {"target": UNIT}, "TWO": {"target": UNIT}}, -) - -TEST_STRING_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#TestStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -TEST_STRING_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#TestStringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -DEFAULTS = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#Defaults"), - members={ - "defaultString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultList": { - "target": TEST_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "defaultBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="YWJj")], - }, - "defaultByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=10)], - }, - "defaultLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=100)], - }, - "defaultFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultMap": { - "target": TEST_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultEnum": { - "target": TEST_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="FOO")], - }, - "defaultIntEnum": { - "target": TEST_INT_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "falseBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=False)], - }, - "emptyBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "zeroByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - "zeroDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - }, -) - -DENSE_BOOLEAN_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#DenseBooleanMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": BOOLEAN}}, -) - -DENSE_NUMBER_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#DenseNumberMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": INTEGER}}, -) - -STRING_SET = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#StringSet"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -DENSE_SET_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#DenseSetMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING_SET}}, -) - -DENSE_STRING_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#DenseStringMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -GREETING_STRUCT = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#GreetingStruct"), - members={"hi": {"target": STRING}}, -) - -DENSE_STRUCT_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#DenseStructMap"), - shape_type=ShapeType.MAP, - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, -) - -EMPTY_INPUT_OUTPUT_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#EmptyInputOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#EmptyStructure", - ) - ], -) - -EMPTY_INPUT_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#EmptyInputOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#EmptyStructure", - ) - ], -) - -EMPTY_INPUT_OUTPUT = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#EmptyInputOutput"), - shape_type=ShapeType.OPERATION, -) - -FLOAT16_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#Float16Input"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -FLOAT16_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#Float16Output"), - members={"value": {"target": DOUBLE}}, -) - -FLOAT16 = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#Float16"), shape_type=ShapeType.OPERATION -) - -FRACTIONAL_SECONDS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#FractionalSecondsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) -DATE_TIME = Schema( - id=ShapeID("smithy.protocoltests.shared#DateTime"), - shape_type=ShapeType.TIMESTAMP, - traits=[Trait.new(id=ShapeID("smithy.api#timestampFormat"), value="date-time")], -) - -FRACTIONAL_SECONDS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#FractionalSecondsOutput"), - members={"datetime": {"target": DATE_TIME}}, -) - -FRACTIONAL_SECONDS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#FractionalSeconds"), - shape_type=ShapeType.OPERATION, -) - -GREETING_WITH_ERRORS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#GreetingWithErrorsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -GREETING_WITH_ERRORS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#GreetingWithErrorsOutput"), - members={"greeting": {"target": STRING}}, -) - -INVALID_GREETING = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#InvalidGreeting"), - traits=[Trait.new(id=ShapeID("smithy.api#error"), value="client")], - members={"Message": {"target": STRING}}, -) - -GREETING_WITH_ERRORS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#GreetingWithErrors"), - shape_type=ShapeType.OPERATION, -) - -NO_INPUT_OUTPUT_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#NoInputOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#NoInputOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), value="smithy.api#Unit" - ) - ], -) - -NO_INPUT_OUTPUT = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#NoInputOutput"), - shape_type=ShapeType.OPERATION, -) - -OPERATION_WITH_DEFAULTS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#OperationWithDefaultsInput"), - members={ - "defaults": {"target": DEFAULTS}, - "clientOptionalDefaults": {"target": CLIENT_OPTIONAL_DEFAULTS}, - "topLevelDefault": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "otherTopLevelDefault": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - }, -) - -OPERATION_WITH_DEFAULTS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#OperationWithDefaultsOutput"), - members={ - "defaultString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="hi")], - }, - "defaultBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=True)], - }, - "defaultList": { - "target": TEST_STRING_LIST, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=())], - }, - "defaultTimestamp": { - "target": TIMESTAMP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "defaultBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="YWJj")], - }, - "defaultByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "defaultInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=10)], - }, - "defaultLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=100)], - }, - "defaultFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1.0)], - }, - "defaultMap": { - "target": TEST_STRING_MAP, - "traits": [Trait.new(id=ShapeID("smithy.api#default"))], - }, - "defaultEnum": { - "target": TEST_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="FOO")], - }, - "defaultIntEnum": { - "target": TEST_INT_ENUM, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=1)], - }, - "emptyString": { - "target": STRING, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "falseBoolean": { - "target": BOOLEAN, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=False)], - }, - "emptyBlob": { - "target": BLOB, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value="")], - }, - "zeroByte": { - "target": BYTE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroShort": { - "target": SHORT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroInteger": { - "target": INTEGER, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroLong": { - "target": LONG, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0)], - }, - "zeroFloat": { - "target": FLOAT, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - "zeroDouble": { - "target": DOUBLE, - "traits": [Trait.new(id=ShapeID("smithy.api#default"), value=0.0)], - }, - }, -) - -OPERATION_WITH_DEFAULTS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#OperationWithDefaults"), - shape_type=ShapeType.OPERATION, -) - -OPTIONAL_INPUT_OUTPUT_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#OptionalInputOutputInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#SimpleStructure", - ) - ], - members={"value": {"target": STRING}}, -) - -OPTIONAL_INPUT_OUTPUT_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#OptionalInputOutputOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#SimpleStructure", - ) - ], - members={"value": {"target": STRING}}, -) - -OPTIONAL_INPUT_OUTPUT = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#OptionalInputOutput"), - shape_type=ShapeType.OPERATION, -) - -RPC_V2_CBOR_DENSE_MAPS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborDenseMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborDenseMapsInputOutput", - ) - ], - members={ - "denseStructMap": {"target": DENSE_STRUCT_MAP}, - "denseNumberMap": {"target": DENSE_NUMBER_MAP}, - "denseBooleanMap": {"target": DENSE_BOOLEAN_MAP}, - "denseStringMap": {"target": DENSE_STRING_MAP}, - "denseSetMap": {"target": DENSE_SET_MAP}, - }, -) - -RPC_V2_CBOR_DENSE_MAPS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborDenseMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborDenseMapsInputOutput", - ) - ], - members={ - "denseStructMap": {"target": DENSE_STRUCT_MAP}, - "denseNumberMap": {"target": DENSE_NUMBER_MAP}, - "denseBooleanMap": {"target": DENSE_BOOLEAN_MAP}, - "denseStringMap": {"target": DENSE_STRING_MAP}, - "denseSetMap": {"target": DENSE_SET_MAP}, - }, -) - -RPC_V2_CBOR_DENSE_MAPS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborDenseMaps"), - shape_type=ShapeType.OPERATION, -) - -BLOB_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#BlobList"), - shape_type=ShapeType.LIST, - members={"member": {"target": BLOB}}, -) - -BOOLEAN_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#BooleanList"), - shape_type=ShapeType.LIST, - members={"member": {"target": BOOLEAN}}, -) - -FOO_ENUM = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#FooEnum"), - shape_type=ShapeType.ENUM, - members={ - "FOO": {"target": UNIT}, - "BAZ": {"target": UNIT}, - "BAR": {"target": UNIT}, - "ONE": {"target": UNIT}, - "ZERO": {"target": UNIT}, - }, -) - -FOO_ENUM_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#FooEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": FOO_ENUM}}, -) - -INTEGER_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#IntegerList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER}}, -) - -INTEGER_ENUM = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#IntegerEnum"), - shape_type=ShapeType.INT_ENUM, - members={"A": {"target": UNIT}, "B": {"target": UNIT}, "C": {"target": UNIT}}, -) - -INTEGER_ENUM_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#IntegerEnumList"), - shape_type=ShapeType.LIST, - members={"member": {"target": INTEGER_ENUM}}, -) - -STRING_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#StringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING}}, -) - -NESTED_STRING_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#NestedStringList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRING_LIST}}, -) - -STRUCTURE_LIST_MEMBER = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#StructureListMember"), - members={"a": {"target": STRING}, "b": {"target": STRING}}, -) - -STRUCTURE_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#StructureList"), - shape_type=ShapeType.LIST, - members={"member": {"target": STRUCTURE_LIST_MEMBER}}, -) - -TIMESTAMP_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#TimestampList"), - shape_type=ShapeType.LIST, - members={"member": {"target": TIMESTAMP}}, -) - -RPC_V2_CBOR_LISTS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborListsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborListInputOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "structureList": {"target": STRUCTURE_LIST}, - "blobList": {"target": BLOB_LIST}, - }, -) - -RPC_V2_CBOR_LISTS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborListsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborListInputOutput", - ) - ], - members={ - "stringList": {"target": STRING_LIST}, - "stringSet": {"target": STRING_SET}, - "integerList": {"target": INTEGER_LIST}, - "booleanList": {"target": BOOLEAN_LIST}, - "timestampList": {"target": TIMESTAMP_LIST}, - "enumList": {"target": FOO_ENUM_LIST}, - "intEnumList": {"target": INTEGER_ENUM_LIST}, - "nestedStringList": {"target": NESTED_STRING_LIST}, - "structureList": {"target": STRUCTURE_LIST}, - "blobList": {"target": BLOB_LIST}, - }, -) - -RPC_V2_CBOR_LISTS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborLists"), - shape_type=ShapeType.OPERATION, -) - -RPC_V2_CBOR_NESTED_UNION = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborNestedUnion"), - shape_type=ShapeType.UNION, - members={"stringValue": {"target": STRING}}, -) - -SPARSE_BOOLEAN_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseBooleanMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": BOOLEAN}}, -) - -SPARSE_NUMBER_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseNumberMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": INTEGER}}, -) - -SPARSE_SET_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseSetMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": STRING_SET}}, -) - -SPARSE_STRING_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#SparseStringMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": STRING}}, -) - -SPARSE_STRUCT_MAP = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseStructMap"), - shape_type=ShapeType.MAP, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"key": {"target": STRING}, "value": {"target": GREETING_STRUCT}}, -) - -RPC_V2_CBOR_SPARSE_MAPS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborSparseMapsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborSparseMapsInputOutput", - ) - ], - members={ - "sparseStructMap": {"target": SPARSE_STRUCT_MAP}, - "sparseNumberMap": {"target": SPARSE_NUMBER_MAP}, - "sparseBooleanMap": {"target": SPARSE_BOOLEAN_MAP}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - "sparseSetMap": {"target": SPARSE_SET_MAP}, - }, -) - -RPC_V2_CBOR_SPARSE_MAPS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborSparseMapsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborSparseMapsInputOutput", - ) - ], - members={ - "sparseStructMap": {"target": SPARSE_STRUCT_MAP}, - "sparseNumberMap": {"target": SPARSE_NUMBER_MAP}, - "sparseBooleanMap": {"target": SPARSE_BOOLEAN_MAP}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - "sparseSetMap": {"target": SPARSE_SET_MAP}, - }, -) - -RPC_V2_CBOR_SPARSE_MAPS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborSparseMaps"), - shape_type=ShapeType.OPERATION, -) - -RPC_V2_CBOR_UNION = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborUnion"), - shape_type=ShapeType.UNION, - members={ - "stringValue": {"target": STRING}, - "unionValue": {"target": RPC_V2_CBOR_NESTED_UNION}, - }, -) - -RPC_V2_CBOR_UNIONS_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborUnionsInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborUnionInputOutput", - ) - ], - members={ - "contents": {"target": RPC_V2_CBOR_UNION}, - "otherValue": {"target": STRING}, - }, -) - -RPC_V2_CBOR_UNIONS_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborUnionsOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RpcV2CborUnionInputOutput", - ) - ], - members={ - "contents": {"target": RPC_V2_CBOR_UNION}, - "otherValue": {"target": STRING}, - }, -) - -RPC_V2_CBOR_UNIONS = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2CborUnions"), - shape_type=ShapeType.OPERATION, -) - -SIMPLE_SCALAR_PROPERTIES_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SimpleScalarPropertiesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#SimpleScalarStructure", - ) - ], - members={ - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "doubleValue": {"target": DOUBLE}, - "floatValue": {"target": FLOAT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "shortValue": {"target": SHORT}, - "stringValue": {"target": STRING}, - "blobValue": {"target": BLOB}, - }, -) - -SIMPLE_SCALAR_PROPERTIES_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SimpleScalarPropertiesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#SimpleScalarStructure", - ) - ], - members={ - "trueBooleanValue": {"target": BOOLEAN}, - "falseBooleanValue": {"target": BOOLEAN}, - "byteValue": {"target": BYTE}, - "doubleValue": {"target": DOUBLE}, - "floatValue": {"target": FLOAT}, - "integerValue": {"target": INTEGER}, - "longValue": {"target": LONG}, - "shortValue": {"target": SHORT}, - "stringValue": {"target": STRING}, - "blobValue": {"target": BLOB}, - }, -) - -SIMPLE_SCALAR_PROPERTIES = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SimpleScalarProperties"), - shape_type=ShapeType.OPERATION, -) - -SPARSE_STRING_LIST = Schema.collection( - id=ShapeID("smithy.protocoltests.shared#SparseStringList"), - shape_type=ShapeType.LIST, - traits=[Trait.new(id=ShapeID("smithy.api#sparse"))], - members={"member": {"target": STRING}}, -) - -SPARSE_NULLS_OPERATION_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseNullsOperationInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#SparseNullsOperationInputOutput", - ) - ], - members={ - "sparseStringList": {"target": SPARSE_STRING_LIST}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - }, -) - -SPARSE_NULLS_OPERATION_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseNullsOperationOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#SparseNullsOperationInputOutput", - ) - ], - members={ - "sparseStringList": {"target": SPARSE_STRING_LIST}, - "sparseStringMap": {"target": SPARSE_STRING_MAP}, - }, -) - -SPARSE_NULLS_OPERATION = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#SparseNullsOperation"), - shape_type=ShapeType.OPERATION, -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutputNested1"), - members={ - "foo": {"target": STRING}, - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - "nested": None, - }, -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutputNested2"), - members={ - "bar": {"target": STRING}, - "recursiveMember": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}, - }, -) - -RECURSIVE_SHAPES_INPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RecursiveShapesInput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutput", - ) - ], - members={"nested": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}}, -) - -RECURSIVE_SHAPES_OUTPUT = Schema.collection( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RecursiveShapesOutput"), - traits=[ - Trait.new( - id=ShapeID("smithy.synthetic#originalShapeId"), - value="smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutput", - ) - ], - members={"nested": {"target": RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1}}, -) - -RECURSIVE_SHAPES = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RecursiveShapes"), - shape_type=ShapeType.OPERATION, -) - -RPC_V2_PROTOCOL = Schema( - id=ShapeID("smithy.protocoltests.rpcv2Cbor#RpcV2Protocol"), - shape_type=ShapeType.SERVICE, - traits=[ - Trait.new(id=ShapeID("smithy.protocols#rpcv2Cbor")), - Trait.new( - id=ShapeID("smithy.rules#endpointBdd"), - value=MappingProxyType( - { - "version": "1.1", - "parameters": MappingProxyType( +n0 = "smithy.framework" +_VEF = "ValidationExceptionField" +_p = "path" +_s = "smithy.api#required" +_m = "message" +_VEFL = "ValidationExceptionFieldList" +_me = "member" +_VE = "ValidationException" +_sm = "smithy.api#error" +_c = "client" +_fL = "fieldList" +n1 = "smithy.protocoltests.rpcv2Cbor" +_COD = "ClientOptionalDefaults" +_smi = "smithy.api#default" +_CNED = "ComplexNestedErrorData" +_F = "Foo" +_CE = "ComplexError" +_TL = "TopLevel" +_N = "Nested" +_TE = "TestEnum" +_FOO = "FOO" +_BAR = "BAR" +_BAZ = "BAZ" +_TIE = "TestIntEnum" +_ONE = "ONE" +_TWO = "TWO" +_TSL = "TestStringList" +_TSM = "TestStringMap" +_k = "key" +_v = "value" +_D = "Defaults" +_dS = "defaultString" +_h = "hi" +_dB = "defaultBoolean" +_dL = "defaultList" +_dT = "defaultTimestamp" +_dBe = "defaultBlob" +_YWJ = "YWJj" +_dBef = "defaultByte" +_dSe = "defaultShort" +_dI = "defaultInteger" +_dLe = "defaultLong" +_dF = "defaultFloat" +_dD = "defaultDouble" +_dM = "defaultMap" +_dE = "defaultEnum" +_dIE = "defaultIntEnum" +_eS = "emptyString" +_v_ = "" +_fB = "falseBoolean" +_eB = "emptyBlob" +_zB = "zeroByte" +_zS = "zeroShort" +_zI = "zeroInteger" +_zL = "zeroLong" +_zF = "zeroFloat" +_zD = "zeroDouble" +_DBM = "DenseBooleanMap" +_DNM = "DenseNumberMap" +n2 = "smithy.protocoltests.shared" +_SS = "StringSet" +_DSM = "DenseSetMap" +_DSMe = "DenseStringMap" +_GS = "GreetingStruct" +_DSMen = "DenseStructMap" +_EIOI = "EmptyInputOutputInput" +_sSI = "smithy.synthetic#originalShapeId" +_sCES = "smithy.protocoltests.rpcv2Cbor#EmptyStructure" +_EIOO = "EmptyInputOutputOutput" +_EIO = "EmptyInputOutput" +_FI = "Float16Input" +_sU = "smithy.api#Unit" +_FO = "Float16Output" +_Fl = "Float16" +_FSI = "FractionalSecondsInput" +_DT = "DateTime" +_sF = "smithy.api#timestampFormat" +_dt = "date-time" +_FSO = "FractionalSecondsOutput" +_d = "datetime" +_FS = "FractionalSeconds" +_GWEI = "GreetingWithErrorsInput" +_GWEO = "GreetingWithErrorsOutput" +_g = "greeting" +_IG = "InvalidGreeting" +_M = "Message" +_GWE = "GreetingWithErrors" +_NIOI = "NoInputOutputInput" +_NIOO = "NoInputOutputOutput" +_NIO = "NoInputOutput" +_OWDI = "OperationWithDefaultsInput" +_de = "defaults" +_cOD = "clientOptionalDefaults" +_tLD = "topLevelDefault" +_oTLD = "otherTopLevelDefault" +_OWDO = "OperationWithDefaultsOutput" +_OWD = "OperationWithDefaults" +_OIOI = "OptionalInputOutputInput" +_sCSS = "smithy.protocoltests.rpcv2Cbor#SimpleStructure" +_OIOO = "OptionalInputOutputOutput" +_OIO = "OptionalInputOutput" +_RVCDMI = "RpcV2CborDenseMapsInput" +_sCRVCDMIO = "smithy.protocoltests.rpcv2Cbor#RpcV2CborDenseMapsInputOutput" +_dSM = "denseStructMap" +_dNM = "denseNumberMap" +_dBM = "denseBooleanMap" +_dSMe = "denseStringMap" +_dSMen = "denseSetMap" +_RVCDMO = "RpcV2CborDenseMapsOutput" +_RVCDM = "RpcV2CborDenseMaps" +_BL = "BlobList" +_BLo = "BooleanList" +_FE = "FooEnum" +_ZERO = "ZERO" +_FEL = "FooEnumList" +_IL = "IntegerList" +_IE = "IntegerEnum" +_A = "A" +_B = "B" +_C = "C" +_IEL = "IntegerEnumList" +_SL = "StringList" +_NSL = "NestedStringList" +_SLM = "StructureListMember" +_a = "a" +_b = "b" +_SLt = "StructureList" +_TLi = "TimestampList" +_RVCLI = "RpcV2CborListsInput" +_sCRVCLIO = "smithy.protocoltests.rpcv2Cbor#RpcV2CborListInputOutput" +_sL = "stringList" +_sS = "stringSet" +_iL = "integerList" +_bL = "booleanList" +_tL = "timestampList" +_eL = "enumList" +_iEL = "intEnumList" +_nSL = "nestedStringList" +_sLt = "structureList" +_bLl = "blobList" +_RVCLO = "RpcV2CborListsOutput" +_RVCL = "RpcV2CborLists" +_RVCNU = "RpcV2CborNestedUnion" +_sV = "stringValue" +_SBM = "SparseBooleanMap" +_smit = "smithy.api#sparse" +_SNM = "SparseNumberMap" +_SSM = "SparseSetMap" +_SSMp = "SparseStringMap" +_SSMpa = "SparseStructMap" +_RVCSMI = "RpcV2CborSparseMapsInput" +_sCRVCSMIO = "smithy.protocoltests.rpcv2Cbor#RpcV2CborSparseMapsInputOutput" +_sSM = "sparseStructMap" +_sNM = "sparseNumberMap" +_sBM = "sparseBooleanMap" +_sSMp = "sparseStringMap" +_sSMpa = "sparseSetMap" +_RVCSMO = "RpcV2CborSparseMapsOutput" +_RVCSM = "RpcV2CborSparseMaps" +_RVCU = "RpcV2CborUnion" +_uV = "unionValue" +_RVCUI = "RpcV2CborUnionsInput" +_sCRVCUIO = "smithy.protocoltests.rpcv2Cbor#RpcV2CborUnionInputOutput" +_co = "contents" +_oV = "otherValue" +_RVCUO = "RpcV2CborUnionsOutput" +_RVCUp = "RpcV2CborUnions" +_SSPI = "SimpleScalarPropertiesInput" +_sCSSS = "smithy.protocoltests.rpcv2Cbor#SimpleScalarStructure" +_tBV = "trueBooleanValue" +_fBV = "falseBooleanValue" +_bV = "byteValue" +_dV = "doubleValue" +_fV = "floatValue" +_iV = "integerValue" +_lV = "longValue" +_sVh = "shortValue" +_bVl = "blobValue" +_SSPO = "SimpleScalarPropertiesOutput" +_SSP = "SimpleScalarProperties" +_SSL = "SparseStringList" +_SNOI = "SparseNullsOperationInput" +_sCSNOIO = "smithy.protocoltests.rpcv2Cbor#SparseNullsOperationInputOutput" +_sSL = "sparseStringList" +_SNOO = "SparseNullsOperationOutput" +_SNO = "SparseNullsOperation" +_RSION = "RecursiveShapesInputOutputNested1" +_f = "foo" +_n = "nested" +_RSIONe = "RecursiveShapesInputOutputNested2" +_ba = "bar" +_rM = "recursiveMember" +_RSI = "RecursiveShapesInput" +_sCRSIO = "smithy.protocoltests.rpcv2Cbor#RecursiveShapesInputOutput" +_RSO = "RecursiveShapesOutput" +_RS = "RecursiveShapes" +_RVP = "RpcV2Protocol" +_sC = "smithy.protocols#rpcv2Cbor" +_sB = "smithy.rules#endpointBdd" + +VALIDATION_EXCEPTION_FIELD = (18, n0, _VEF, 0, (_p, _m), ((3, 1), (3, 1))) + +VALIDATION_EXCEPTION_FIELD_LIST = ( + 16, + n0, + _VEFL, + 0, + (_me,), + ((VALIDATION_EXCEPTION_FIELD, 0),), +) + +VALIDATION_EXCEPTION = ( + 18, + n0, + _VE, + {_sm: _c}, + (_m, _fL), + ((3, 1), (VALIDATION_EXCEPTION_FIELD_LIST, 0)), +) + +CLIENT_OPTIONAL_DEFAULTS = (18, n1, _COD, 0, (_me,), ((7, {_smi: 0}),)) + +COMPLEX_NESTED_ERROR_DATA = (18, n1, _CNED, 0, (_F,), ((3, 0),)) + +COMPLEX_ERROR = ( + 18, + n1, + _CE, + {_sm: _c}, + (_TL, _N), + ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), +) + +TEST_ENUM = (14, n1, _TE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) + +TEST_INT_ENUM = (15, n1, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) + +TEST_STRING_LIST = (16, n1, _TSL, 0, (_me,), ((3, 0),)) + +TEST_STRING_MAP = (17, n1, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) + +DEFAULTS = ( + 18, + n1, + _D, + 0, + ( + _dS, + _dB, + _dL, + _dT, + _dBe, + _dBef, + _dSe, + _dI, + _dLe, + _dF, + _dD, + _dM, + _dE, + _dIE, + _eS, + _fB, + _eB, + _zB, + _zS, + _zI, + _zL, + _zF, + _zD, + ), + ( + (3, {_smi: _h}), + (2, {_smi: True}), + (TEST_STRING_LIST, {_smi: ()}), + (4, {_smi: 0}), + (1, {_smi: _YWJ}), + (5, {_smi: 1}), + (6, {_smi: 1}), + (7, {_smi: 10}), + (8, {_smi: 100}), + (9, {_smi: 1.0}), + (10, {_smi: 1.0}), + (TEST_STRING_MAP, {_smi: None}), + (TEST_ENUM, {_smi: _FOO}), + (TEST_INT_ENUM, {_smi: 1}), + (3, {_smi: _v_}), + (2, {_smi: False}), + (1, {_smi: _v_}), + (5, {_smi: 0}), + (6, {_smi: 0}), + (7, {_smi: 0}), + (8, {_smi: 0}), + (9, {_smi: 0.0}), + (10, {_smi: 0.0}), + ), +) + +DENSE_BOOLEAN_MAP = (17, n1, _DBM, 0, (_k, _v), ((3, 0), (2, 0))) + +DENSE_NUMBER_MAP = (17, n1, _DNM, 0, (_k, _v), ((3, 0), (7, 0))) + +STRING_SET = (16, n2, _SS, 0, (_me,), ((3, 0),)) + +DENSE_SET_MAP = (17, n1, _DSM, 0, (_k, _v), ((3, 0), (STRING_SET, 0))) + +DENSE_STRING_MAP = (17, n1, _DSMe, 0, (_k, _v), ((3, 0), (3, 0))) + +GREETING_STRUCT = (18, n2, _GS, 0, (_h,), ((3, 0),)) + +DENSE_STRUCT_MAP = (17, n1, _DSMen, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) + +EMPTY_INPUT_OUTPUT_INPUT = (18, n1, _EIOI, {_sSI: _sCES}) + +EMPTY_INPUT_OUTPUT_OUTPUT = (18, n1, _EIOO, {_sSI: _sCES}) + +EMPTY_INPUT_OUTPUT = ( + 23, + n1, + _EIO, + 0, + EMPTY_INPUT_OUTPUT_INPUT, + EMPTY_INPUT_OUTPUT_OUTPUT, + (), +) + +FLOAT16_INPUT = (18, n1, _FI, {_sSI: _sU}) + +FLOAT16_OUTPUT = (18, n1, _FO, 0, (_v,), ((10, 0),)) + +FLOAT16 = (23, n1, _Fl, 0, FLOAT16_INPUT, FLOAT16_OUTPUT, ()) + +FRACTIONAL_SECONDS_INPUT = (18, n1, _FSI, {_sSI: _sU}) + +DATE_TIME = (4, n2, _DT, {_sF: _dt}) + +FRACTIONAL_SECONDS_OUTPUT = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) + +FRACTIONAL_SECONDS = ( + 23, + n1, + _FS, + 0, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), +) + +GREETING_WITH_ERRORS_INPUT = (18, n1, _GWEI, {_sSI: _sU}) + +GREETING_WITH_ERRORS_OUTPUT = (18, n1, _GWEO, 0, (_g,), ((3, 0),)) + +INVALID_GREETING = (18, n1, _IG, {_sm: _c}, (_M,), ((3, 0),)) + +GREETING_WITH_ERRORS = ( + 23, + n1, + _GWE, + 0, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (INVALID_GREETING, COMPLEX_ERROR), +) + +NO_INPUT_OUTPUT_INPUT = (18, n1, _NIOI, {_sSI: _sU}) + +NO_INPUT_OUTPUT_OUTPUT = (18, n1, _NIOO, {_sSI: _sU}) + +NO_INPUT_OUTPUT = (23, n1, _NIO, 0, NO_INPUT_OUTPUT_INPUT, NO_INPUT_OUTPUT_OUTPUT, ()) + +OPERATION_WITH_DEFAULTS_INPUT = ( + 18, + n1, + _OWDI, + 0, + (_de, _cOD, _tLD, _oTLD), + ((DEFAULTS, 0), (CLIENT_OPTIONAL_DEFAULTS, 0), (3, {_smi: _h}), (7, {_smi: 0})), +) + +OPERATION_WITH_DEFAULTS_OUTPUT = ( + 18, + n1, + _OWDO, + 0, + ( + _dS, + _dB, + _dL, + _dT, + _dBe, + _dBef, + _dSe, + _dI, + _dLe, + _dF, + _dD, + _dM, + _dE, + _dIE, + _eS, + _fB, + _eB, + _zB, + _zS, + _zI, + _zL, + _zF, + _zD, + ), + ( + (3, {_smi: _h}), + (2, {_smi: True}), + (TEST_STRING_LIST, {_smi: ()}), + (4, {_smi: 0}), + (1, {_smi: _YWJ}), + (5, {_smi: 1}), + (6, {_smi: 1}), + (7, {_smi: 10}), + (8, {_smi: 100}), + (9, {_smi: 1.0}), + (10, {_smi: 1.0}), + (TEST_STRING_MAP, {_smi: None}), + (TEST_ENUM, {_smi: _FOO}), + (TEST_INT_ENUM, {_smi: 1}), + (3, {_smi: _v_}), + (2, {_smi: False}), + (1, {_smi: _v_}), + (5, {_smi: 0}), + (6, {_smi: 0}), + (7, {_smi: 0}), + (8, {_smi: 0}), + (9, {_smi: 0.0}), + (10, {_smi: 0.0}), + ), +) + +OPERATION_WITH_DEFAULTS = ( + 23, + n1, + _OWD, + 0, + OPERATION_WITH_DEFAULTS_INPUT, + OPERATION_WITH_DEFAULTS_OUTPUT, + (VALIDATION_EXCEPTION,), +) + +OPTIONAL_INPUT_OUTPUT_INPUT = (18, n1, _OIOI, {_sSI: _sCSS}, (_v,), ((3, 0),)) + +OPTIONAL_INPUT_OUTPUT_OUTPUT = (18, n1, _OIOO, {_sSI: _sCSS}, (_v,), ((3, 0),)) + +OPTIONAL_INPUT_OUTPUT = ( + 23, + n1, + _OIO, + 0, + OPTIONAL_INPUT_OUTPUT_INPUT, + OPTIONAL_INPUT_OUTPUT_OUTPUT, + (), +) + +RPC_V2_CBOR_DENSE_MAPS_INPUT = ( + 18, + n1, + _RVCDMI, + {_sSI: _sCRVCDMIO}, + (_dSM, _dNM, _dBM, _dSMe, _dSMen), + ( + (DENSE_STRUCT_MAP, 0), + (DENSE_NUMBER_MAP, 0), + (DENSE_BOOLEAN_MAP, 0), + (DENSE_STRING_MAP, 0), + (DENSE_SET_MAP, 0), + ), +) + +RPC_V2_CBOR_DENSE_MAPS_OUTPUT = ( + 18, + n1, + _RVCDMO, + {_sSI: _sCRVCDMIO}, + (_dSM, _dNM, _dBM, _dSMe, _dSMen), + ( + (DENSE_STRUCT_MAP, 0), + (DENSE_NUMBER_MAP, 0), + (DENSE_BOOLEAN_MAP, 0), + (DENSE_STRING_MAP, 0), + (DENSE_SET_MAP, 0), + ), +) + +RPC_V2_CBOR_DENSE_MAPS = ( + 23, + n1, + _RVCDM, + 0, + RPC_V2_CBOR_DENSE_MAPS_INPUT, + RPC_V2_CBOR_DENSE_MAPS_OUTPUT, + (VALIDATION_EXCEPTION,), +) + +BLOB_LIST = (16, n2, _BL, 0, (_me,), ((1, 0),)) + +BOOLEAN_LIST = (16, n2, _BLo, 0, (_me,), ((2, 0),)) + +FOO_ENUM = ( + 14, + n2, + _FE, + 0, + (_FOO, _BAZ, _BAR, _ONE, _ZERO), + ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), +) + +FOO_ENUM_LIST = (16, n2, _FEL, 0, (_me,), ((FOO_ENUM, 0),)) + +INTEGER_LIST = (16, n2, _IL, 0, (_me,), ((7, 0),)) + +INTEGER_ENUM = (15, n2, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) + +INTEGER_ENUM_LIST = (16, n2, _IEL, 0, (_me,), ((INTEGER_ENUM, 0),)) + +STRING_LIST = (16, n2, _SL, 0, (_me,), ((3, 0),)) + +NESTED_STRING_LIST = (16, n2, _NSL, 0, (_me,), ((STRING_LIST, 0),)) + +STRUCTURE_LIST_MEMBER = (18, n1, _SLM, 0, (_a, _b), ((3, 0), (3, 0))) + +STRUCTURE_LIST = (16, n1, _SLt, 0, (_me,), ((STRUCTURE_LIST_MEMBER, 0),)) + +TIMESTAMP_LIST = (16, n2, _TLi, 0, (_me,), ((4, 0),)) + +RPC_V2_CBOR_LISTS_INPUT = ( + 18, + n1, + _RVCLI, + {_sSI: _sCRVCLIO}, + (_sL, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _sLt, _bLl), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (STRUCTURE_LIST, 0), + (BLOB_LIST, 0), + ), +) + +RPC_V2_CBOR_LISTS_OUTPUT = ( + 18, + n1, + _RVCLO, + {_sSI: _sCRVCLIO}, + (_sL, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _sLt, _bLl), + ( + (STRING_LIST, 0), + (STRING_SET, 0), + (INTEGER_LIST, 0), + (BOOLEAN_LIST, 0), + (TIMESTAMP_LIST, 0), + (FOO_ENUM_LIST, 0), + (INTEGER_ENUM_LIST, 0), + (NESTED_STRING_LIST, 0), + (STRUCTURE_LIST, 0), + (BLOB_LIST, 0), + ), +) + +RPC_V2_CBOR_LISTS = ( + 23, + n1, + _RVCL, + 0, + RPC_V2_CBOR_LISTS_INPUT, + RPC_V2_CBOR_LISTS_OUTPUT, + (VALIDATION_EXCEPTION,), +) + +RPC_V2_CBOR_NESTED_UNION = (19, n1, _RVCNU, 0, (_sV,), ((3, 0),)) + +SPARSE_BOOLEAN_MAP = (17, n1, _SBM, 64, (_k, _v), ((3, 0), (2, 0))) + +SPARSE_NUMBER_MAP = (17, n1, _SNM, 64, (_k, _v), ((3, 0), (7, 0))) + +SPARSE_SET_MAP = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (STRING_SET, 0))) + +SPARSE_STRING_MAP = (17, n2, _SSMp, 64, (_k, _v), ((3, 0), (3, 0))) + +SPARSE_STRUCT_MAP = (17, n1, _SSMpa, 64, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) + +RPC_V2_CBOR_SPARSE_MAPS_INPUT = ( + 18, + n1, + _RVCSMI, + {_sSI: _sCRVCSMIO}, + (_sSM, _sNM, _sBM, _sSMp, _sSMpa), + ( + (SPARSE_STRUCT_MAP, 0), + (SPARSE_NUMBER_MAP, 0), + (SPARSE_BOOLEAN_MAP, 0), + (SPARSE_STRING_MAP, 0), + (SPARSE_SET_MAP, 0), + ), +) + +RPC_V2_CBOR_SPARSE_MAPS_OUTPUT = ( + 18, + n1, + _RVCSMO, + {_sSI: _sCRVCSMIO}, + (_sSM, _sNM, _sBM, _sSMp, _sSMpa), + ( + (SPARSE_STRUCT_MAP, 0), + (SPARSE_NUMBER_MAP, 0), + (SPARSE_BOOLEAN_MAP, 0), + (SPARSE_STRING_MAP, 0), + (SPARSE_SET_MAP, 0), + ), +) + +RPC_V2_CBOR_SPARSE_MAPS = ( + 23, + n1, + _RVCSM, + 0, + RPC_V2_CBOR_SPARSE_MAPS_INPUT, + RPC_V2_CBOR_SPARSE_MAPS_OUTPUT, + (VALIDATION_EXCEPTION,), +) + +RPC_V2_CBOR_UNION = ( + 19, + n1, + _RVCU, + 0, + (_sV, _uV), + ((3, 0), (RPC_V2_CBOR_NESTED_UNION, 0)), +) + +RPC_V2_CBOR_UNIONS_INPUT = ( + 18, + n1, + _RVCUI, + {_sSI: _sCRVCUIO}, + (_co, _oV), + ((RPC_V2_CBOR_UNION, 0), (3, 0)), +) + +RPC_V2_CBOR_UNIONS_OUTPUT = ( + 18, + n1, + _RVCUO, + {_sSI: _sCRVCUIO}, + (_co, _oV), + ((RPC_V2_CBOR_UNION, 0), (3, 0)), +) + +RPC_V2_CBOR_UNIONS = ( + 23, + n1, + _RVCUp, + 0, + RPC_V2_CBOR_UNIONS_INPUT, + RPC_V2_CBOR_UNIONS_OUTPUT, + (), +) + +SIMPLE_SCALAR_PROPERTIES_INPUT = ( + 18, + n1, + _SSPI, + {_sSI: _sCSSS}, + (_tBV, _fBV, _bV, _dV, _fV, _iV, _lV, _sVh, _sV, _bVl), + ((2, 0), (2, 0), (5, 0), (10, 0), (9, 0), (7, 0), (8, 0), (6, 0), (3, 0), (1, 0)), +) + +SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( + 18, + n1, + _SSPO, + {_sSI: _sCSSS}, + (_tBV, _fBV, _bV, _dV, _fV, _iV, _lV, _sVh, _sV, _bVl), + ((2, 0), (2, 0), (5, 0), (10, 0), (9, 0), (7, 0), (8, 0), (6, 0), (3, 0), (1, 0)), +) + +SIMPLE_SCALAR_PROPERTIES = ( + 23, + n1, + _SSP, + 0, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), +) + +SPARSE_STRING_LIST = (16, n2, _SSL, 64, (_me,), ((3, 0),)) + +SPARSE_NULLS_OPERATION_INPUT = ( + 18, + n1, + _SNOI, + {_sSI: _sCSNOIO}, + (_sSL, _sSMp), + ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), +) + +SPARSE_NULLS_OPERATION_OUTPUT = ( + 18, + n1, + _SNOO, + {_sSI: _sCSNOIO}, + (_sSL, _sSMp), + ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), +) + +SPARSE_NULLS_OPERATION = ( + 23, + n1, + _SNO, + 0, + SPARSE_NULLS_OPERATION_INPUT, + SPARSE_NULLS_OPERATION_OUTPUT, + (), +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( + 18, + n1, + _RSION, + 0, + (_f, _n), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( + 18, + n1, + _RSIONe, + 0, + (_ba, _rM), + ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), +) + +RECURSIVE_SHAPES_INPUT = ( + 18, + n1, + _RSI, + {_sSI: _sCRSIO}, + (_n,), + ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES_OUTPUT = ( + 18, + n1, + _RSO, + {_sSI: _sCRSIO}, + (_n,), + ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES = (23, n1, _RS, 0, RECURSIVE_SHAPES_INPUT, RECURSIVE_SHAPES_OUTPUT, ()) + +RPC_V2_PROTOCOL = ( + 21, + n1, + _RVP, + { + _sC: None, + _sB: MappingProxyType( + { + "version": "1.1", + "parameters": MappingProxyType( + { + "endpoint": MappingProxyType( + { + "builtIn": "SDK::Endpoint", + "required": False, + "documentation": "Endpoint used for making requests. Should be formatted as a URI.", + "type": "string", + } + ) + } + ), + "conditions": ( + MappingProxyType( { + "fn": "isSet", + "argv": (MappingProxyType({"ref": "endpoint"}),), + } + ), + ), + "results": ( + MappingProxyType( + { + "conditions": (), "endpoint": MappingProxyType( { - "builtIn": "SDK::Endpoint", - "required": False, - "documentation": "Endpoint used for making requests. Should be formatted as a URI.", - "type": "string", + "url": MappingProxyType({"ref": "endpoint"}), + "properties": MappingProxyType({}), + "headers": MappingProxyType({}), } - ) + ), + "type": "endpoint", } ), - "conditions": ( - MappingProxyType( - { - "fn": "isSet", - "argv": (MappingProxyType({"ref": "endpoint"}),), - } - ), - ), - "results": ( - MappingProxyType( - { - "conditions": (), - "endpoint": MappingProxyType( - { - "url": MappingProxyType({"ref": "endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), - } - ), - "type": "endpoint", - } - ), - MappingProxyType( - { - "conditions": (), - "error": "(default endpointRuleSet) endpoint is not set - you must configure an endpoint.", - "type": "error", - } - ), + MappingProxyType( + { + "conditions": (), + "error": "(default endpointRuleSet) endpoint is not set - you must configure an endpoint.", + "type": "error", + } ), - "root": 2, - "nodeCount": 2, - "nodes": "/////wAAAAH/////AAAAAAX14QEF9eEC", - } - ), + ), + "root": 2, + "nodeCount": 2, + "nodes": "/////wAAAAH/////AAAAAAX14QEF9eEC", + } ), - ], -) - -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["nested"] = Schema.member( - id=RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.id.with_member("nested"), - target=RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, - index=1, + }, ) diff --git a/codegen-output/rpcv2-cbor/src/rpcv2cbor/models.py b/codegen-output/rpcv2-cbor/src/rpcv2cbor/models.py index d4725da61..5b6d90c8a 100644 --- a/codegen-output/rpcv2-cbor/src/rpcv2cbor/models.py +++ b/codegen-output/rpcv2-cbor/src/rpcv2cbor/models.py @@ -7,6 +7,7 @@ import logging from typing import Any, Literal, Self, Union +from smithy_core._schema_compact import hydrate from smithy_core.deserializers import ShapeDeserializer from smithy_core.documents import TypeRegistry from smithy_core.exceptions import ModeledError, SerializationError @@ -101,15 +102,12 @@ class ValidationExceptionField: """A detailed description of the validation failure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VALIDATION_EXCEPTION_FIELD, self) + serializer.write_struct(hydrate(_SCHEMA_VALIDATION_EXCEPTION_FIELD), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_VALIDATION_EXCEPTION_FIELD.members["path"], self.path - ) - serializer.write_string( - _SCHEMA_VALIDATION_EXCEPTION_FIELD.members["message"], self.message - ) + members = hydrate(_SCHEMA_VALIDATION_EXCEPTION_FIELD).members_by_index + serializer.write_string(members[0], self.path) + serializer.write_string(members[1], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -118,23 +116,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_VALIDATION_EXCEPTION_FIELD) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["path"] = de.read_string( - _SCHEMA_VALIDATION_EXCEPTION_FIELD.members["path"] - ) + kwargs["path"] = de.read_string(members[0]) case 1: - kwargs["message"] = de.read_string( - _SCHEMA_VALIDATION_EXCEPTION_FIELD.members["message"] - ) + kwargs["message"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_VALIDATION_EXCEPTION_FIELD, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) if "path" not in kwargs: kwargs["path"] = "" if "message" not in kwargs: @@ -145,7 +141,7 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: def _serialize_validation_exception_field_list( serializer: ShapeSerializer, schema: Schema, value: list[ValidationExceptionField] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -185,17 +181,14 @@ class ValidationException(ServiceError): """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_VALIDATION_EXCEPTION, self) + serializer.write_struct(hydrate(_SCHEMA_VALIDATION_EXCEPTION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_VALIDATION_EXCEPTION.members["message"], self.message - ) + members = hydrate(_SCHEMA_VALIDATION_EXCEPTION).members_by_index + serializer.write_string(members[0], self.message) if self.field_list is not None: _serialize_validation_exception_field_list( - serializer, - _SCHEMA_VALIDATION_EXCEPTION.members["fieldList"], - self.field_list, + serializer, members[1], self.field_list ) @classmethod @@ -205,23 +198,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_VALIDATION_EXCEPTION) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_VALIDATION_EXCEPTION.members["message"] - ) + kwargs["message"] = de.read_string(members[0]) case 1: kwargs["field_list"] = _deserialize_validation_exception_field_list( - de, _SCHEMA_VALIDATION_EXCEPTION.members["fieldList"] + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_VALIDATION_EXCEPTION, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -232,13 +225,12 @@ class ClientOptionalDefaults: member: int = 0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS, self) + serializer.write_struct(hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS).members_by_index if self.member is not None: - serializer.write_integer( - _SCHEMA_CLIENT_OPTIONAL_DEFAULTS.members["member"], self.member - ) + serializer.write_integer(members[0], self.member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -247,18 +239,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["member"] = de.read_integer( - _SCHEMA_CLIENT_OPTIONAL_DEFAULTS.members["member"] - ) + kwargs["member"] = de.read_integer(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_CLIENT_OPTIONAL_DEFAULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -269,13 +261,12 @@ class ComplexNestedErrorData: foo: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"], self.foo - ) + serializer.write_string(members[0], self.foo) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -284,18 +275,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_NESTED_ERROR_DATA) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_COMPLEX_NESTED_ERROR_DATA.members["Foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_NESTED_ERROR_DATA, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -310,18 +301,15 @@ class ComplexError(ServiceError): nested: ComplexNestedErrorData | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_COMPLEX_ERROR, self) + serializer.write_struct(hydrate(_SCHEMA_COMPLEX_ERROR), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_COMPLEX_ERROR).members_by_index if self.top_level is not None: - serializer.write_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"], self.top_level - ) + serializer.write_string(members[0], self.top_level) if self.nested is not None: - serializer.write_struct( - _SCHEMA_COMPLEX_ERROR.members["Nested"], self.nested - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -330,21 +318,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_COMPLEX_ERROR) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["top_level"] = de.read_string( - _SCHEMA_COMPLEX_ERROR.members["TopLevel"] - ) + kwargs["top_level"] = de.read_string(members[0]) case 1: kwargs["nested"] = ComplexNestedErrorData.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_COMPLEX_ERROR, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -362,7 +350,7 @@ class TestIntEnum(UnknownEnumMixin, IntEnum): def _serialize_test_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -372,7 +360,7 @@ def _deserialize_test_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -389,7 +377,7 @@ def _serialize_test_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -398,7 +386,7 @@ def _deserialize_test_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -462,68 +450,33 @@ class Defaults: zero_double: float = 0.0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_DEFAULTS, self) + serializer.write_struct(hydrate(_SCHEMA_DEFAULTS), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_DEFAULTS.members["defaultString"], self.default_string - ) - serializer.write_boolean( - _SCHEMA_DEFAULTS.members["defaultBoolean"], self.default_boolean - ) - _serialize_test_string_list( - serializer, _SCHEMA_DEFAULTS.members["defaultList"], self.default_list - ) - serializer.write_timestamp( - _SCHEMA_DEFAULTS.members["defaultTimestamp"], self.default_timestamp - ) - serializer.write_blob( - _SCHEMA_DEFAULTS.members["defaultBlob"], self.default_blob - ) - serializer.write_byte( - _SCHEMA_DEFAULTS.members["defaultByte"], self.default_byte - ) - serializer.write_short( - _SCHEMA_DEFAULTS.members["defaultShort"], self.default_short - ) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["defaultInteger"], self.default_integer - ) - serializer.write_long( - _SCHEMA_DEFAULTS.members["defaultLong"], self.default_long - ) - serializer.write_float( - _SCHEMA_DEFAULTS.members["defaultFloat"], self.default_float - ) - serializer.write_double( - _SCHEMA_DEFAULTS.members["defaultDouble"], self.default_double - ) - _serialize_test_string_map( - serializer, _SCHEMA_DEFAULTS.members["defaultMap"], self.default_map - ) - serializer.write_string( - _SCHEMA_DEFAULTS.members["defaultEnum"], self.default_enum - ) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["defaultIntEnum"], self.default_int_enum - ) - serializer.write_string( - _SCHEMA_DEFAULTS.members["emptyString"], self.empty_string - ) - serializer.write_boolean( - _SCHEMA_DEFAULTS.members["falseBoolean"], self.false_boolean - ) - serializer.write_blob(_SCHEMA_DEFAULTS.members["emptyBlob"], self.empty_blob) - serializer.write_byte(_SCHEMA_DEFAULTS.members["zeroByte"], self.zero_byte) - serializer.write_short(_SCHEMA_DEFAULTS.members["zeroShort"], self.zero_short) - serializer.write_integer( - _SCHEMA_DEFAULTS.members["zeroInteger"], self.zero_integer - ) - serializer.write_long(_SCHEMA_DEFAULTS.members["zeroLong"], self.zero_long) - serializer.write_float(_SCHEMA_DEFAULTS.members["zeroFloat"], self.zero_float) - serializer.write_double( - _SCHEMA_DEFAULTS.members["zeroDouble"], self.zero_double - ) + members = hydrate(_SCHEMA_DEFAULTS).members_by_index + serializer.write_string(members[0], self.default_string) + serializer.write_boolean(members[1], self.default_boolean) + _serialize_test_string_list(serializer, members[2], self.default_list) + serializer.write_timestamp(members[3], self.default_timestamp) + serializer.write_blob(members[4], self.default_blob) + serializer.write_byte(members[5], self.default_byte) + serializer.write_short(members[6], self.default_short) + serializer.write_integer(members[7], self.default_integer) + serializer.write_long(members[8], self.default_long) + serializer.write_float(members[9], self.default_float) + serializer.write_double(members[10], self.default_double) + _serialize_test_string_map(serializer, members[11], self.default_map) + serializer.write_string(members[12], self.default_enum) + serializer.write_integer(members[13], self.default_int_enum) + serializer.write_string(members[14], self.empty_string) + serializer.write_boolean(members[15], self.false_boolean) + serializer.write_blob(members[16], self.empty_blob) + serializer.write_byte(members[17], self.zero_byte) + serializer.write_short(members[18], self.zero_short) + serializer.write_integer(members[19], self.zero_integer) + serializer.write_long(members[20], self.zero_long) + serializer.write_float(members[21], self.zero_float) + serializer.write_double(members[22], self.zero_double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -532,128 +485,90 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_DEFAULTS) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["default_string"] = de.read_string( - _SCHEMA_DEFAULTS.members["defaultString"] - ) + kwargs["default_string"] = de.read_string(members[0]) case 1: - kwargs["default_boolean"] = de.read_boolean( - _SCHEMA_DEFAULTS.members["defaultBoolean"] - ) + kwargs["default_boolean"] = de.read_boolean(members[1]) case 2: kwargs["default_list"] = _deserialize_test_string_list( - de, _SCHEMA_DEFAULTS.members["defaultList"] + de, members[2] ) case 3: - kwargs["default_timestamp"] = de.read_timestamp( - _SCHEMA_DEFAULTS.members["defaultTimestamp"] - ) + kwargs["default_timestamp"] = de.read_timestamp(members[3]) case 4: - kwargs["default_blob"] = de.read_blob( - _SCHEMA_DEFAULTS.members["defaultBlob"] - ) + kwargs["default_blob"] = de.read_blob(members[4]) case 5: - kwargs["default_byte"] = de.read_byte( - _SCHEMA_DEFAULTS.members["defaultByte"] - ) + kwargs["default_byte"] = de.read_byte(members[5]) case 6: - kwargs["default_short"] = de.read_short( - _SCHEMA_DEFAULTS.members["defaultShort"] - ) + kwargs["default_short"] = de.read_short(members[6]) case 7: - kwargs["default_integer"] = de.read_integer( - _SCHEMA_DEFAULTS.members["defaultInteger"] - ) + kwargs["default_integer"] = de.read_integer(members[7]) case 8: - kwargs["default_long"] = de.read_long( - _SCHEMA_DEFAULTS.members["defaultLong"] - ) + kwargs["default_long"] = de.read_long(members[8]) case 9: - kwargs["default_float"] = de.read_float( - _SCHEMA_DEFAULTS.members["defaultFloat"] - ) + kwargs["default_float"] = de.read_float(members[9]) case 10: - kwargs["default_double"] = de.read_double( - _SCHEMA_DEFAULTS.members["defaultDouble"] - ) + kwargs["default_double"] = de.read_double(members[10]) case 11: kwargs["default_map"] = _deserialize_test_string_map( - de, _SCHEMA_DEFAULTS.members["defaultMap"] + de, members[11] ) case 12: - kwargs["default_enum"] = TestEnum( - de.read_string(_SCHEMA_DEFAULTS.members["defaultEnum"]) - ) + kwargs["default_enum"] = TestEnum(de.read_string(members[12])) case 13: kwargs["default_int_enum"] = TestIntEnum( - de.read_integer(_SCHEMA_DEFAULTS.members["defaultIntEnum"]) + de.read_integer(members[13]) ) case 14: - kwargs["empty_string"] = de.read_string( - _SCHEMA_DEFAULTS.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[14]) case 15: - kwargs["false_boolean"] = de.read_boolean( - _SCHEMA_DEFAULTS.members["falseBoolean"] - ) + kwargs["false_boolean"] = de.read_boolean(members[15]) case 16: - kwargs["empty_blob"] = de.read_blob( - _SCHEMA_DEFAULTS.members["emptyBlob"] - ) + kwargs["empty_blob"] = de.read_blob(members[16]) case 17: - kwargs["zero_byte"] = de.read_byte( - _SCHEMA_DEFAULTS.members["zeroByte"] - ) + kwargs["zero_byte"] = de.read_byte(members[17]) case 18: - kwargs["zero_short"] = de.read_short( - _SCHEMA_DEFAULTS.members["zeroShort"] - ) + kwargs["zero_short"] = de.read_short(members[18]) case 19: - kwargs["zero_integer"] = de.read_integer( - _SCHEMA_DEFAULTS.members["zeroInteger"] - ) + kwargs["zero_integer"] = de.read_integer(members[19]) case 20: - kwargs["zero_long"] = de.read_long( - _SCHEMA_DEFAULTS.members["zeroLong"] - ) + kwargs["zero_long"] = de.read_long(members[20]) case 21: - kwargs["zero_float"] = de.read_float( - _SCHEMA_DEFAULTS.members["zeroFloat"] - ) + kwargs["zero_float"] = de.read_float(members[21]) case 22: - kwargs["zero_double"] = de.read_double( - _SCHEMA_DEFAULTS.members["zeroDouble"] - ) + kwargs["zero_double"] = de.read_double(members[22]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_DEFAULTS, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -661,7 +576,7 @@ def _serialize_dense_boolean_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, bool] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_boolean(value_schema, v)) @@ -670,7 +585,7 @@ def _deserialize_dense_boolean_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, bool]: result: dict[str, bool] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -687,7 +602,7 @@ def _serialize_dense_number_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_integer(value_schema, v)) @@ -696,7 +611,7 @@ def _deserialize_dense_number_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int]: result: dict[str, int] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -712,7 +627,7 @@ def _read_value(k: str, d: ShapeDeserializer): def _serialize_string_set( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -722,7 +637,7 @@ def _deserialize_string_set( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -739,7 +654,7 @@ def _serialize_dense_set_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str]] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: _serialize_string_set(vs, value_schema, v)) @@ -748,7 +663,7 @@ def _deserialize_dense_set_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str]]: result: dict[str, list[str]] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -765,7 +680,7 @@ def _serialize_dense_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_string(value_schema, v)) @@ -774,7 +689,7 @@ def _deserialize_dense_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str]: result: dict[str, str] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -794,11 +709,12 @@ class GreetingStruct: hi: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_STRUCT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_STRUCT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_STRUCT).members_by_index if self.hi is not None: - serializer.write_string(_SCHEMA_GREETING_STRUCT.members["hi"], self.hi) + serializer.write_string(members[0], self.hi) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -807,16 +723,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_STRUCT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["hi"] = de.read_string(_SCHEMA_GREETING_STRUCT.members["hi"]) + kwargs["hi"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_STRUCT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -824,7 +742,7 @@ def _serialize_dense_struct_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): m.entry(k, lambda vs: vs.write_struct(value_schema, v)) @@ -833,7 +751,7 @@ def _deserialize_dense_struct_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct]: result: dict[str, GreetingStruct] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -851,7 +769,7 @@ class EmptyInputOutputInput: """Dataclass for EmptyInputOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_EMPTY_INPUT_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -863,13 +781,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_EMPTY_INPUT_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -889,7 +808,7 @@ class EmptyInputOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_EMPTY_INPUT_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_EMPTY_INPUT_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -901,25 +820,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_EMPTY_INPUT_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_EMPTY_INPUT_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs EMPTY_INPUT_OUTPUT = APIOperation( input=EmptyInputOutputInput, output=EmptyInputOutputOutput, - schema=_SCHEMA_EMPTY_INPUT_OUTPUT, - input_schema=_SCHEMA_EMPTY_INPUT_OUTPUT_INPUT, - output_schema=_SCHEMA_EMPTY_INPUT_OUTPUT_OUTPUT, + static_schema=_SCHEMA_EMPTY_INPUT_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -928,7 +845,7 @@ class Float16Input: """Dataclass for Float16Input structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLOAT16_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FLOAT16_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -940,13 +857,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLOAT16_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FLOAT16_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -968,11 +886,12 @@ class Float16Output: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FLOAT16_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FLOAT16_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FLOAT16_OUTPUT).members_by_index if self.value is not None: - serializer.write_double(_SCHEMA_FLOAT16_OUTPUT.members["value"], self.value) + serializer.write_double(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -981,30 +900,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FLOAT16_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_double( - _SCHEMA_FLOAT16_OUTPUT.members["value"] - ) + kwargs["value"] = de.read_double(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FLOAT16_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FLOAT16 = APIOperation( input=Float16Input, output=Float16Output, - schema=_SCHEMA_FLOAT16, - input_schema=_SCHEMA_FLOAT16_INPUT, - output_schema=_SCHEMA_FLOAT16_OUTPUT, + static_schema=_SCHEMA_FLOAT16, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -1013,7 +929,7 @@ class FractionalSecondsInput: """Dataclass for FractionalSecondsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1025,13 +941,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1053,13 +970,12 @@ class FractionalSecondsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT).members_by_index if self.datetime_ is not None: - serializer.write_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"], self.datetime_ - ) + serializer.write_timestamp(members[0], self.datetime_) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1068,30 +984,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["datetime_"] = de.read_timestamp( - _SCHEMA_FRACTIONAL_SECONDS_OUTPUT.members["datetime"] - ) + kwargs["datetime_"] = de.read_timestamp(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs FRACTIONAL_SECONDS = APIOperation( input=FractionalSecondsInput, output=FractionalSecondsOutput, - schema=_SCHEMA_FRACTIONAL_SECONDS, - input_schema=_SCHEMA_FRACTIONAL_SECONDS_INPUT, - output_schema=_SCHEMA_FRACTIONAL_SECONDS_OUTPUT, + static_schema=_SCHEMA_FRACTIONAL_SECONDS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -1100,7 +1013,7 @@ class GreetingWithErrorsInput: """Dataclass for GreetingWithErrorsInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1112,13 +1025,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_GREETING_WITH_ERRORS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1140,13 +1054,12 @@ class GreetingWithErrorsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT).members_by_index if self.greeting is not None: - serializer.write_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"], self.greeting - ) + serializer.write_string(members[0], self.greeting) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1155,20 +1068,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_GREETING_WITH_ERRORS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["greeting"] = de.read_string( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT.members["greeting"] - ) + kwargs["greeting"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_GREETING_WITH_ERRORS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1179,13 +1090,12 @@ class InvalidGreeting(ServiceError): fault: Literal["client", "server"] | None = "client" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_INVALID_GREETING, self) + serializer.write_struct(hydrate(_SCHEMA_INVALID_GREETING), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_INVALID_GREETING).members_by_index if self.message is not None: - serializer.write_string( - _SCHEMA_INVALID_GREETING.members["Message"], self.message - ) + serializer.write_string(members[0], self.message) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1194,27 +1104,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_INVALID_GREETING) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["message"] = de.read_string( - _SCHEMA_INVALID_GREETING.members["Message"] - ) + kwargs["message"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_INVALID_GREETING, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs GREETING_WITH_ERRORS = APIOperation( input=GreetingWithErrorsInput, output=GreetingWithErrorsOutput, - schema=_SCHEMA_GREETING_WITH_ERRORS, - input_schema=_SCHEMA_GREETING_WITH_ERRORS_INPUT, - output_schema=_SCHEMA_GREETING_WITH_ERRORS_OUTPUT, + static_schema=_SCHEMA_GREETING_WITH_ERRORS, error_registry=TypeRegistry( { ShapeID("smithy.protocoltests.rpcv2Cbor#InvalidGreeting"): InvalidGreeting, @@ -1222,7 +1130,6 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: } ), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[_SCHEMA_INVALID_GREETING, _SCHEMA_COMPLEX_ERROR], ) @@ -1231,7 +1138,7 @@ class NoInputOutputInput: """Dataclass for NoInputOutputInput structure.""" def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1243,13 +1150,14 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_OUTPUT_INPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_OUTPUT_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1269,7 +1177,7 @@ class NoInputOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_NO_INPUT_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_NO_INPUT_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): pass @@ -1281,25 +1189,23 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_NO_INPUT_OUTPUT_OUTPUT) - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_NO_INPUT_OUTPUT_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs NO_INPUT_OUTPUT = APIOperation( input=NoInputOutputInput, output=NoInputOutputOutput, - schema=_SCHEMA_NO_INPUT_OUTPUT, - input_schema=_SCHEMA_NO_INPUT_OUTPUT_INPUT, - output_schema=_SCHEMA_NO_INPUT_OUTPUT_OUTPUT, + static_schema=_SCHEMA_NO_INPUT_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -1316,31 +1222,21 @@ class OperationWithDefaultsInput: other_top_level_default: int = 0 def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT).members_by_index if self.defaults is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["defaults"], self.defaults - ) + serializer.write_struct(members[0], self.defaults) if self.client_optional_defaults is not None: - serializer.write_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["clientOptionalDefaults"], - self.client_optional_defaults, - ) + serializer.write_struct(members[1], self.client_optional_defaults) if self.top_level_default is not None: - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["topLevelDefault"], - self.top_level_default, - ) + serializer.write_string(members[2], self.top_level_default) if self.other_top_level_default is not None: - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["otherTopLevelDefault"], - self.other_top_level_default, - ) + serializer.write_integer(members[3], self.other_top_level_default) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1349,9 +1245,11 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["defaults"] = Defaults.deserialize(de) @@ -1361,23 +1259,15 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case 2: - kwargs["top_level_default"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members["topLevelDefault"] - ) + kwargs["top_level_default"] = de.read_string(members[2]) case 3: - kwargs["other_top_level_default"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT.members[ - "otherTopLevelDefault" - ] - ) + kwargs["other_top_level_default"] = de.read_integer(members[3]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1443,98 +1333,33 @@ class OperationWithDefaultsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultString"], - self.default_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBoolean"], - self.default_boolean, - ) - _serialize_test_string_list( - serializer, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultList"], - self.default_list, - ) - serializer.write_timestamp( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultTimestamp"], - self.default_timestamp, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBlob"], - self.default_blob, - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultByte"], - self.default_byte, - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultShort"], - self.default_short, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultInteger"], - self.default_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultLong"], - self.default_long, - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultFloat"], - self.default_float, - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDouble"], - self.default_double, - ) - _serialize_test_string_map( - serializer, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultMap"], - self.default_map, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultEnum"], - self.default_enum, - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultIntEnum"], - self.default_int_enum, - ) - serializer.write_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyString"], - self.empty_string, - ) - serializer.write_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["falseBoolean"], - self.false_boolean, - ) - serializer.write_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyBlob"], self.empty_blob - ) - serializer.write_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroByte"], self.zero_byte - ) - serializer.write_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroShort"], self.zero_short - ) - serializer.write_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroInteger"], - self.zero_integer, - ) - serializer.write_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroLong"], self.zero_long - ) - serializer.write_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroFloat"], self.zero_float - ) - serializer.write_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroDouble"], - self.zero_double, - ) + members = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT).members_by_index + serializer.write_string(members[0], self.default_string) + serializer.write_boolean(members[1], self.default_boolean) + _serialize_test_string_list(serializer, members[2], self.default_list) + serializer.write_timestamp(members[3], self.default_timestamp) + serializer.write_blob(members[4], self.default_blob) + serializer.write_byte(members[5], self.default_byte) + serializer.write_short(members[6], self.default_short) + serializer.write_integer(members[7], self.default_integer) + serializer.write_long(members[8], self.default_long) + serializer.write_float(members[9], self.default_float) + serializer.write_double(members[10], self.default_double) + _serialize_test_string_map(serializer, members[11], self.default_map) + serializer.write_string(members[12], self.default_enum) + serializer.write_integer(members[13], self.default_int_enum) + serializer.write_string(members[14], self.empty_string) + serializer.write_boolean(members[15], self.false_boolean) + serializer.write_blob(members[16], self.empty_blob) + serializer.write_byte(members[17], self.zero_byte) + serializer.write_short(members[18], self.zero_short) + serializer.write_integer(members[19], self.zero_integer) + serializer.write_long(members[20], self.zero_long) + serializer.write_float(members[21], self.zero_float) + serializer.write_double(members[22], self.zero_double) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1543,155 +1368,101 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["default_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultString"] - ) + kwargs["default_string"] = de.read_string(members[0]) case 1: - kwargs["default_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBoolean"] - ) + kwargs["default_boolean"] = de.read_boolean(members[1]) case 2: kwargs["default_list"] = _deserialize_test_string_list( - de, - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultList"], + de, members[2] ) case 3: - kwargs["default_timestamp"] = de.read_timestamp( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultTimestamp" - ] - ) + kwargs["default_timestamp"] = de.read_timestamp(members[3]) case 4: - kwargs["default_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultBlob"] - ) + kwargs["default_blob"] = de.read_blob(members[4]) case 5: - kwargs["default_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultByte"] - ) + kwargs["default_byte"] = de.read_byte(members[5]) case 6: - kwargs["default_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultShort"] - ) + kwargs["default_short"] = de.read_short(members[6]) case 7: - kwargs["default_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultInteger"] - ) + kwargs["default_integer"] = de.read_integer(members[7]) case 8: - kwargs["default_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultLong"] - ) + kwargs["default_long"] = de.read_long(members[8]) case 9: - kwargs["default_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultFloat"] - ) + kwargs["default_float"] = de.read_float(members[9]) case 10: - kwargs["default_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultDouble"] - ) + kwargs["default_double"] = de.read_double(members[10]) case 11: kwargs["default_map"] = _deserialize_test_string_map( - de, _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["defaultMap"] + de, members[11] ) case 12: - kwargs["default_enum"] = TestEnum( - de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultEnum" - ] - ) - ) + kwargs["default_enum"] = TestEnum(de.read_string(members[12])) case 13: kwargs["default_int_enum"] = TestIntEnum( - de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members[ - "defaultIntEnum" - ] - ) + de.read_integer(members[13]) ) case 14: - kwargs["empty_string"] = de.read_string( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyString"] - ) + kwargs["empty_string"] = de.read_string(members[14]) case 15: - kwargs["false_boolean"] = de.read_boolean( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["falseBoolean"] - ) + kwargs["false_boolean"] = de.read_boolean(members[15]) case 16: - kwargs["empty_blob"] = de.read_blob( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["emptyBlob"] - ) + kwargs["empty_blob"] = de.read_blob(members[16]) case 17: - kwargs["zero_byte"] = de.read_byte( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroByte"] - ) + kwargs["zero_byte"] = de.read_byte(members[17]) case 18: - kwargs["zero_short"] = de.read_short( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroShort"] - ) + kwargs["zero_short"] = de.read_short(members[18]) case 19: - kwargs["zero_integer"] = de.read_integer( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroInteger"] - ) + kwargs["zero_integer"] = de.read_integer(members[19]) case 20: - kwargs["zero_long"] = de.read_long( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroLong"] - ) + kwargs["zero_long"] = de.read_long(members[20]) case 21: - kwargs["zero_float"] = de.read_float( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroFloat"] - ) + kwargs["zero_float"] = de.read_float(members[21]) case 22: - kwargs["zero_double"] = de.read_double( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT.members["zeroDouble"] - ) + kwargs["zero_double"] = de.read_double(members[22]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OPERATION_WITH_DEFAULTS = APIOperation( input=OperationWithDefaultsInput, output=OperationWithDefaultsOutput, - schema=_SCHEMA_OPERATION_WITH_DEFAULTS, - input_schema=_SCHEMA_OPERATION_WITH_DEFAULTS_INPUT, - output_schema=_SCHEMA_OPERATION_WITH_DEFAULTS_OUTPUT, + static_schema=_SCHEMA_OPERATION_WITH_DEFAULTS, error_registry=TypeRegistry( {ShapeID("smithy.framework#ValidationException"): ValidationException} ), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[_SCHEMA_VALIDATION_EXCEPTION], ) @@ -1702,13 +1473,12 @@ class OptionalInputOutputInput: value: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT).members_by_index if self.value is not None: - serializer.write_string( - _SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT.members["value"], self.value - ) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1717,20 +1487,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT.members["value"] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1752,13 +1520,12 @@ class OptionalInputOutputOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT).members_by_index if self.value is not None: - serializer.write_string( - _SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT.members["value"], self.value - ) + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1767,32 +1534,27 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["value"] = de.read_string( - _SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT.members["value"] - ) + kwargs["value"] = de.read_string(members[0]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs OPTIONAL_INPUT_OUTPUT = APIOperation( input=OptionalInputOutputInput, output=OptionalInputOutputOutput, - schema=_SCHEMA_OPTIONAL_INPUT_OUTPUT, - input_schema=_SCHEMA_OPTIONAL_INPUT_OUTPUT_INPUT, - output_schema=_SCHEMA_OPTIONAL_INPUT_OUTPUT_OUTPUT, + static_schema=_SCHEMA_OPTIONAL_INPUT_OUTPUT, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -1811,43 +1573,24 @@ class RpcV2CborDenseMapsInput: dense_set_map: dict[str, list[str]] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT).members_by_index if self.dense_struct_map is not None: - _serialize_dense_struct_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseStructMap"], - self.dense_struct_map, - ) + _serialize_dense_struct_map(serializer, members[0], self.dense_struct_map) if self.dense_number_map is not None: - _serialize_dense_number_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseNumberMap"], - self.dense_number_map, - ) + _serialize_dense_number_map(serializer, members[1], self.dense_number_map) if self.dense_boolean_map is not None: - _serialize_dense_boolean_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseBooleanMap"], - self.dense_boolean_map, - ) + _serialize_dense_boolean_map(serializer, members[2], self.dense_boolean_map) if self.dense_string_map is not None: - _serialize_dense_string_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseStringMap"], - self.dense_string_map, - ) + _serialize_dense_string_map(serializer, members[3], self.dense_string_map) if self.dense_set_map is not None: - _serialize_dense_set_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseSetMap"], - self.dense_set_map, - ) + _serialize_dense_set_map(serializer, members[4], self.dense_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1856,44 +1599,38 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dense_struct_map"] = _deserialize_dense_struct_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseStructMap"], + de, members[0] ) case 1: kwargs["dense_number_map"] = _deserialize_dense_number_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseNumberMap"], + de, members[1] ) case 2: kwargs["dense_boolean_map"] = _deserialize_dense_boolean_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseBooleanMap"], + de, members[2] ) case 3: kwargs["dense_string_map"] = _deserialize_dense_string_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseStringMap"], + de, members[3] ) case 4: - kwargs["dense_set_map"] = _deserialize_dense_set_map( - de, _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT.members["denseSetMap"] - ) + kwargs["dense_set_map"] = _deserialize_dense_set_map(de, members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -1923,43 +1660,24 @@ class RpcV2CborDenseMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT).members_by_index if self.dense_struct_map is not None: - _serialize_dense_struct_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseStructMap"], - self.dense_struct_map, - ) + _serialize_dense_struct_map(serializer, members[0], self.dense_struct_map) if self.dense_number_map is not None: - _serialize_dense_number_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseNumberMap"], - self.dense_number_map, - ) + _serialize_dense_number_map(serializer, members[1], self.dense_number_map) if self.dense_boolean_map is not None: - _serialize_dense_boolean_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseBooleanMap"], - self.dense_boolean_map, - ) + _serialize_dense_boolean_map(serializer, members[2], self.dense_boolean_map) if self.dense_string_map is not None: - _serialize_dense_string_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseStringMap"], - self.dense_string_map, - ) + _serialize_dense_string_map(serializer, members[3], self.dense_string_map) if self.dense_set_map is not None: - _serialize_dense_set_map( - serializer, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseSetMap"], - self.dense_set_map, - ) + _serialize_dense_set_map(serializer, members[4], self.dense_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -1968,67 +1686,56 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["dense_struct_map"] = _deserialize_dense_struct_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseStructMap"], + de, members[0] ) case 1: kwargs["dense_number_map"] = _deserialize_dense_number_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseNumberMap"], + de, members[1] ) case 2: kwargs["dense_boolean_map"] = _deserialize_dense_boolean_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members[ - "denseBooleanMap" - ], + de, members[2] ) case 3: kwargs["dense_string_map"] = _deserialize_dense_string_map( - de, - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseStringMap"], + de, members[3] ) case 4: - kwargs["dense_set_map"] = _deserialize_dense_set_map( - de, _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT.members["denseSetMap"] - ) + kwargs["dense_set_map"] = _deserialize_dense_set_map(de, members[4]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RPC_V2_CBOR_DENSE_MAPS = APIOperation( input=RpcV2CborDenseMapsInput, output=RpcV2CborDenseMapsOutput, - schema=_SCHEMA_RPC_V2_CBOR_DENSE_MAPS, - input_schema=_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_INPUT, - output_schema=_SCHEMA_RPC_V2_CBOR_DENSE_MAPS_OUTPUT, + static_schema=_SCHEMA_RPC_V2_CBOR_DENSE_MAPS, error_registry=TypeRegistry( {ShapeID("smithy.framework#ValidationException"): ValidationException} ), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[_SCHEMA_VALIDATION_EXCEPTION], ) def _serialize_blob_list( serializer: ShapeSerializer, schema: Schema, value: list[bytes] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_blob(member_schema, e) @@ -2038,7 +1745,7 @@ def _deserialize_blob_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[bytes]: result: list[bytes] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2054,7 +1761,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_boolean_list( serializer: ShapeSerializer, schema: Schema, value: list[bool] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_boolean(member_schema, e) @@ -2064,7 +1771,7 @@ def _deserialize_boolean_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[bool]: result: list[bool] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2088,7 +1795,7 @@ class FooEnum(UnknownEnumMixin, StrEnum): def _serialize_foo_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2098,7 +1805,7 @@ def _deserialize_foo_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2114,7 +1821,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_integer_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -2124,7 +1831,7 @@ def _deserialize_integer_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2146,7 +1853,7 @@ class IntegerEnum(UnknownEnumMixin, IntEnum): def _serialize_integer_enum_list( serializer: ShapeSerializer, schema: Schema, value: list[int] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_integer(member_schema, e) @@ -2156,7 +1863,7 @@ def _deserialize_integer_enum_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[int]: result: list[int] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2172,7 +1879,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_string(member_schema, e) @@ -2182,7 +1889,7 @@ def _deserialize_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str]: result: list[str] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2198,7 +1905,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_nested_string_list( serializer: ShapeSerializer, schema: Schema, value: list[list[str]] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: _serialize_string_list(ls, member_schema, e) @@ -2208,7 +1915,7 @@ def _deserialize_nested_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[list[str]]: result: list[list[str]] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2230,14 +1937,15 @@ class StructureListMember: b: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, self) + serializer.write_struct(hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER).members_by_index if self.a is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["a"], self.a) + serializer.write_string(members[0], self.a) if self.b is not None: - serializer.write_string(_SCHEMA_STRUCTURE_LIST_MEMBER.members["b"], self.b) + serializer.write_string(members[1], self.b) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2246,30 +1954,28 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_STRUCTURE_LIST_MEMBER) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["a"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["a"] - ) + kwargs["a"] = de.read_string(members[0]) case 1: - kwargs["b"] = de.read_string( - _SCHEMA_STRUCTURE_LIST_MEMBER.members["b"] - ) + kwargs["b"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_STRUCTURE_LIST_MEMBER, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs def _serialize_structure_list( serializer: ShapeSerializer, schema: Schema, value: list[StructureListMember] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_struct(member_schema, e) @@ -2294,7 +2000,7 @@ def _read_value(d: ShapeDeserializer): def _serialize_timestamp_list( serializer: ShapeSerializer, schema: Schema, value: list[datetime] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ls.write_timestamp(member_schema, e) @@ -2304,7 +2010,7 @@ def _deserialize_timestamp_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[datetime]: result: list[datetime] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -2343,78 +2049,41 @@ class RpcV2CborListsInput: blob_list: list[bytes] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_LISTS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_LISTS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_LISTS_INPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[8], self.structure_list) if self.blob_list is not None: - _serialize_blob_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["blobList"], - self.blob_list, - ) + _serialize_blob_list(serializer, members[9], self.blob_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2423,63 +2092,53 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_LISTS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["structureList"] + de, members[8] ) case 9: - kwargs["blob_list"] = _deserialize_blob_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_INPUT.members["blobList"] - ) + kwargs["blob_list"] = _deserialize_blob_list(de, members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RPC_V2_CBOR_LISTS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -2520,78 +2179,41 @@ class RpcV2CborListsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT).members_by_index if self.string_list is not None: - _serialize_string_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["stringList"], - self.string_list, - ) + _serialize_string_list(serializer, members[0], self.string_list) if self.string_set is not None: - _serialize_string_set( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["stringSet"], - self.string_set, - ) + _serialize_string_set(serializer, members[1], self.string_set) if self.integer_list is not None: - _serialize_integer_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["integerList"], - self.integer_list, - ) + _serialize_integer_list(serializer, members[2], self.integer_list) if self.boolean_list is not None: - _serialize_boolean_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["booleanList"], - self.boolean_list, - ) + _serialize_boolean_list(serializer, members[3], self.boolean_list) if self.timestamp_list is not None: - _serialize_timestamp_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["timestampList"], - self.timestamp_list, - ) + _serialize_timestamp_list(serializer, members[4], self.timestamp_list) if self.enum_list is not None: - _serialize_foo_enum_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["enumList"], - self.enum_list, - ) + _serialize_foo_enum_list(serializer, members[5], self.enum_list) if self.int_enum_list is not None: - _serialize_integer_enum_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["intEnumList"], - self.int_enum_list, - ) + _serialize_integer_enum_list(serializer, members[6], self.int_enum_list) if self.nested_string_list is not None: _serialize_nested_string_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["nestedStringList"], - self.nested_string_list, + serializer, members[7], self.nested_string_list ) if self.structure_list is not None: - _serialize_structure_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["structureList"], - self.structure_list, - ) + _serialize_structure_list(serializer, members[8], self.structure_list) if self.blob_list is not None: - _serialize_blob_list( - serializer, - _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["blobList"], - self.blob_list, - ) + _serialize_blob_list(serializer, members[9], self.blob_list) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2600,77 +2222,64 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["string_list"] = _deserialize_string_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["stringList"] - ) + kwargs["string_list"] = _deserialize_string_list(de, members[0]) case 1: - kwargs["string_set"] = _deserialize_string_set( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["stringSet"] - ) + kwargs["string_set"] = _deserialize_string_set(de, members[1]) case 2: - kwargs["integer_list"] = _deserialize_integer_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["integerList"] - ) + kwargs["integer_list"] = _deserialize_integer_list(de, members[2]) case 3: - kwargs["boolean_list"] = _deserialize_boolean_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["booleanList"] - ) + kwargs["boolean_list"] = _deserialize_boolean_list(de, members[3]) case 4: kwargs["timestamp_list"] = _deserialize_timestamp_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["timestampList"] + de, members[4] ) case 5: - kwargs["enum_list"] = _deserialize_foo_enum_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["enumList"] - ) + kwargs["enum_list"] = _deserialize_foo_enum_list(de, members[5]) case 6: kwargs["int_enum_list"] = _deserialize_integer_enum_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["intEnumList"] + de, members[6] ) case 7: kwargs["nested_string_list"] = _deserialize_nested_string_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["nestedStringList"] + de, members[7] ) case 8: kwargs["structure_list"] = _deserialize_structure_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["structureList"] + de, members[8] ) case 9: - kwargs["blob_list"] = _deserialize_blob_list( - de, _SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT.members["blobList"] - ) + kwargs["blob_list"] = _deserialize_blob_list(de, members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RPC_V2_CBOR_LISTS = APIOperation( input=RpcV2CborListsInput, output=RpcV2CborListsOutput, - schema=_SCHEMA_RPC_V2_CBOR_LISTS, - input_schema=_SCHEMA_RPC_V2_CBOR_LISTS_INPUT, - output_schema=_SCHEMA_RPC_V2_CBOR_LISTS_OUTPUT, + static_schema=_SCHEMA_RPC_V2_CBOR_LISTS, error_registry=TypeRegistry( {ShapeID("smithy.framework#ValidationException"): ValidationException} ), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[_SCHEMA_VALIDATION_EXCEPTION], ) @@ -2679,20 +2288,16 @@ class RpcV2CborNestedUnionStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_NESTED_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_NESTED_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_RPC_V2_CBOR_NESTED_UNION.members["stringValue"], self.value - ) + members = hydrate(_SCHEMA_RPC_V2_CBOR_NESTED_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_RPC_V2_CBOR_NESTED_UNION.members["stringValue"] - ) - ) + members = hydrate(_SCHEMA_RPC_V2_CBOR_NESTED_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -2729,7 +2334,9 @@ class _RpcV2CborNestedUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> RpcV2CborNestedUnion: self._result = None - deserializer.read_struct(_SCHEMA_RPC_V2_CBOR_NESTED_UNION, self._consumer) + deserializer.read_struct( + hydrate(_SCHEMA_RPC_V2_CBOR_NESTED_UNION), self._consumer + ) if self._result is None: raise SerializationError( @@ -2760,7 +2367,7 @@ def _serialize_sparse_boolean_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, bool | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -2772,7 +2379,7 @@ def _deserialize_sparse_boolean_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, bool | None]: result: dict[str, bool | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2789,7 +2396,7 @@ def _serialize_sparse_number_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, int | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -2801,7 +2408,7 @@ def _deserialize_sparse_number_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, int | None]: result: dict[str, int | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2818,7 +2425,7 @@ def _serialize_sparse_set_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, list[str] | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -2830,7 +2437,7 @@ def _deserialize_sparse_set_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, list[str] | None]: result: dict[str, list[str] | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2847,7 +2454,7 @@ def _serialize_sparse_string_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, str | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -2859,7 +2466,7 @@ def _deserialize_sparse_string_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, str | None]: result: dict[str, str | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2876,7 +2483,7 @@ def _serialize_sparse_struct_map( serializer: ShapeSerializer, schema: Schema, value: dict[str, GreetingStruct | None] ) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): if v is None: m.entry(k, lambda vs: vs.write_null(value_schema)) @@ -2888,7 +2495,7 @@ def _deserialize_sparse_struct_map( deserializer: ShapeDeserializer, schema: Schema ) -> dict[str, GreetingStruct | None]: result: dict[str, GreetingStruct | None] = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: ShapeDeserializer): if d.is_null(): @@ -2916,43 +2523,26 @@ class RpcV2CborSparseMapsInput: sparse_set_map: dict[str, list[str] | None] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT).members_by_index if self.sparse_struct_map is not None: - _serialize_sparse_struct_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members["sparseStructMap"], - self.sparse_struct_map, - ) + _serialize_sparse_struct_map(serializer, members[0], self.sparse_struct_map) if self.sparse_number_map is not None: - _serialize_sparse_number_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members["sparseNumberMap"], - self.sparse_number_map, - ) + _serialize_sparse_number_map(serializer, members[1], self.sparse_number_map) if self.sparse_boolean_map is not None: _serialize_sparse_boolean_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members["sparseBooleanMap"], - self.sparse_boolean_map, + serializer, members[2], self.sparse_boolean_map ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[3], self.sparse_string_map) if self.sparse_set_map is not None: - _serialize_sparse_set_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members["sparseSetMap"], - self.sparse_set_map, - ) + _serialize_sparse_set_map(serializer, members[4], self.sparse_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -2961,53 +2551,40 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_struct_map"] = _deserialize_sparse_struct_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members[ - "sparseStructMap" - ], + de, members[0] ) case 1: kwargs["sparse_number_map"] = _deserialize_sparse_number_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members[ - "sparseNumberMap" - ], + de, members[1] ) case 2: kwargs["sparse_boolean_map"] = _deserialize_sparse_boolean_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members[ - "sparseBooleanMap" - ], + de, members[2] ) case 3: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members[ - "sparseStringMap" - ], + de, members[3] ) case 4: kwargs["sparse_set_map"] = _deserialize_sparse_set_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT.members["sparseSetMap"], + de, members[4] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3037,43 +2614,26 @@ class RpcV2CborSparseMapsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT).members_by_index if self.sparse_struct_map is not None: - _serialize_sparse_struct_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members["sparseStructMap"], - self.sparse_struct_map, - ) + _serialize_sparse_struct_map(serializer, members[0], self.sparse_struct_map) if self.sparse_number_map is not None: - _serialize_sparse_number_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members["sparseNumberMap"], - self.sparse_number_map, - ) + _serialize_sparse_number_map(serializer, members[1], self.sparse_number_map) if self.sparse_boolean_map is not None: _serialize_sparse_boolean_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members["sparseBooleanMap"], - self.sparse_boolean_map, + serializer, members[2], self.sparse_boolean_map ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[3], self.sparse_string_map) if self.sparse_set_map is not None: - _serialize_sparse_set_map( - serializer, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members["sparseSetMap"], - self.sparse_set_map, - ) + _serialize_sparse_set_map(serializer, members[4], self.sparse_set_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3082,67 +2642,51 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_struct_map"] = _deserialize_sparse_struct_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members[ - "sparseStructMap" - ], + de, members[0] ) case 1: kwargs["sparse_number_map"] = _deserialize_sparse_number_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members[ - "sparseNumberMap" - ], + de, members[1] ) case 2: kwargs["sparse_boolean_map"] = _deserialize_sparse_boolean_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members[ - "sparseBooleanMap" - ], + de, members[2] ) case 3: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members[ - "sparseStringMap" - ], + de, members[3] ) case 4: kwargs["sparse_set_map"] = _deserialize_sparse_set_map( - de, - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT.members["sparseSetMap"], + de, members[4] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RPC_V2_CBOR_SPARSE_MAPS = APIOperation( input=RpcV2CborSparseMapsInput, output=RpcV2CborSparseMapsOutput, - schema=_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS, - input_schema=_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_INPUT, - output_schema=_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS_OUTPUT, + static_schema=_SCHEMA_RPC_V2_CBOR_SPARSE_MAPS, error_registry=TypeRegistry( {ShapeID("smithy.framework#ValidationException"): ValidationException} ), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[_SCHEMA_VALIDATION_EXCEPTION], ) @@ -3151,20 +2695,16 @@ class RpcV2CborUnionStringValue: value: str def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_string( - _SCHEMA_RPC_V2_CBOR_UNION.members["stringValue"], self.value - ) + members = hydrate(_SCHEMA_RPC_V2_CBOR_UNION).members_by_index + serializer.write_string(members[0], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: - return cls( - value=deserializer.read_string( - _SCHEMA_RPC_V2_CBOR_UNION.members["stringValue"] - ) - ) + members = hydrate(_SCHEMA_RPC_V2_CBOR_UNION).members_by_index + return cls(value=deserializer.read_string(members[0])) @dataclass @@ -3172,12 +2712,11 @@ class RpcV2CborUnionUnionValue: value: RpcV2CborNestedUnion def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_UNION, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_UNION), self) def serialize_members(self, serializer: ShapeSerializer): - serializer.write_struct( - _SCHEMA_RPC_V2_CBOR_UNION.members["unionValue"], self.value - ) + members = hydrate(_SCHEMA_RPC_V2_CBOR_UNION).members_by_index + serializer.write_struct(members[1], self.value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3218,7 +2757,7 @@ class _RpcV2CborUnionDeserializer: def deserialize(self, deserializer: ShapeDeserializer) -> RpcV2CborUnion: self._result = None - deserializer.read_struct(_SCHEMA_RPC_V2_CBOR_UNION, self._consumer) + deserializer.read_struct(hydrate(_SCHEMA_RPC_V2_CBOR_UNION), self._consumer) if self._result is None: raise SerializationError( @@ -3255,18 +2794,15 @@ class RpcV2CborUnionsInput: other_value: str | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_UNIONS_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_UNIONS_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_UNIONS_INPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_RPC_V2_CBOR_UNIONS_INPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) if self.other_value is not None: - serializer.write_string( - _SCHEMA_RPC_V2_CBOR_UNIONS_INPUT.members["otherValue"], self.other_value - ) + serializer.write_string(members[1], self.other_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3275,21 +2811,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_UNIONS_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _RpcV2CborUnionDeserializer().deserialize(de) case 1: - kwargs["other_value"] = de.read_string( - _SCHEMA_RPC_V2_CBOR_UNIONS_INPUT.members["otherValue"] - ) + kwargs["other_value"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RPC_V2_CBOR_UNIONS_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3313,19 +2849,15 @@ class RpcV2CborUnionsOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT).members_by_index if self.contents is not None: - serializer.write_struct( - _SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT.members["contents"], self.contents - ) + serializer.write_struct(members[0], self.contents) if self.other_value is not None: - serializer.write_string( - _SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT.members["otherValue"], - self.other_value, - ) + serializer.write_string(members[1], self.other_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3334,33 +2866,30 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["contents"] = _RpcV2CborUnionDeserializer().deserialize(de) case 1: - kwargs["other_value"] = de.read_string( - _SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT.members["otherValue"] - ) + kwargs["other_value"] = de.read_string(members[1]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RPC_V2_CBOR_UNIONS = APIOperation( input=RpcV2CborUnionsInput, output=RpcV2CborUnionsOutput, - schema=_SCHEMA_RPC_V2_CBOR_UNIONS, - input_schema=_SCHEMA_RPC_V2_CBOR_UNIONS_INPUT, - output_schema=_SCHEMA_RPC_V2_CBOR_UNIONS_OUTPUT, + static_schema=_SCHEMA_RPC_V2_CBOR_UNIONS, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -3389,68 +2918,39 @@ class SimpleScalarPropertiesInput: blob_value: bytes | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT).members_by_index if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[0], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[1], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[2], self.byte_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[3], self.double_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[4], self.float_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[5], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[6], self.long_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[7], self.short_value) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[8], self.string_value) if self.blob_value is not None: - serializer.write_blob( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["blobValue"], - self.blob_value, - ) + serializer.write_blob(members[9], self.blob_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3459,69 +2959,45 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[0]) case 1: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[1]) case 2: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[2]) case 3: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[3]) case 4: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[4]) case 5: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[5]) case 6: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[6]) case 7: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[7]) case 8: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[8]) case 9: - kwargs["blob_value"] = de.read_blob( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT.members["blobValue"] - ) + kwargs["blob_value"] = de.read_blob(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3561,68 +3037,39 @@ class SimpleScalarPropertiesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT).members_by_index if self.true_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["trueBooleanValue"], - self.true_boolean_value, - ) + serializer.write_boolean(members[0], self.true_boolean_value) if self.false_boolean_value is not None: - serializer.write_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["falseBooleanValue"], - self.false_boolean_value, - ) + serializer.write_boolean(members[1], self.false_boolean_value) if self.byte_value is not None: - serializer.write_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"], - self.byte_value, - ) + serializer.write_byte(members[2], self.byte_value) if self.double_value is not None: - serializer.write_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"], - self.double_value, - ) + serializer.write_double(members[3], self.double_value) if self.float_value is not None: - serializer.write_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"], - self.float_value, - ) + serializer.write_float(members[4], self.float_value) if self.integer_value is not None: - serializer.write_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"], - self.integer_value, - ) + serializer.write_integer(members[5], self.integer_value) if self.long_value is not None: - serializer.write_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"], - self.long_value, - ) + serializer.write_long(members[6], self.long_value) if self.short_value is not None: - serializer.write_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"], - self.short_value, - ) + serializer.write_short(members[7], self.short_value) if self.string_value is not None: - serializer.write_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"], - self.string_value, - ) + serializer.write_string(members[8], self.string_value) if self.blob_value is not None: - serializer.write_blob( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["blobValue"], - self.blob_value, - ) + serializer.write_blob(members[9], self.blob_value) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3631,88 +3078,61 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["true_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "trueBooleanValue" - ] - ) + kwargs["true_boolean_value"] = de.read_boolean(members[0]) case 1: - kwargs["false_boolean_value"] = de.read_boolean( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members[ - "falseBooleanValue" - ] - ) + kwargs["false_boolean_value"] = de.read_boolean(members[1]) case 2: - kwargs["byte_value"] = de.read_byte( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["byteValue"] - ) + kwargs["byte_value"] = de.read_byte(members[2]) case 3: - kwargs["double_value"] = de.read_double( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["doubleValue"] - ) + kwargs["double_value"] = de.read_double(members[3]) case 4: - kwargs["float_value"] = de.read_float( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["floatValue"] - ) + kwargs["float_value"] = de.read_float(members[4]) case 5: - kwargs["integer_value"] = de.read_integer( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["integerValue"] - ) + kwargs["integer_value"] = de.read_integer(members[5]) case 6: - kwargs["long_value"] = de.read_long( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["longValue"] - ) + kwargs["long_value"] = de.read_long(members[6]) case 7: - kwargs["short_value"] = de.read_short( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["shortValue"] - ) + kwargs["short_value"] = de.read_short(members[7]) case 8: - kwargs["string_value"] = de.read_string( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["stringValue"] - ) + kwargs["string_value"] = de.read_string(members[8]) case 9: - kwargs["blob_value"] = de.read_blob( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT.members["blobValue"] - ) + kwargs["blob_value"] = de.read_blob(members[9]) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SIMPLE_SCALAR_PROPERTIES = APIOperation( input=SimpleScalarPropertiesInput, output=SimpleScalarPropertiesOutput, - schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, - input_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_INPUT, - output_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES_OUTPUT, + static_schema=_SCHEMA_SIMPLE_SCALAR_PROPERTIES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) def _serialize_sparse_string_list( serializer: ShapeSerializer, schema: Schema, value: list[str | None] ) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: if e is None: @@ -3725,7 +3145,7 @@ def _deserialize_sparse_string_list( deserializer: ShapeDeserializer, schema: Schema ) -> list[str | None]: result: list[str | None] = [] - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] def _read_value(d: ShapeDeserializer): if d.is_null(): @@ -3747,22 +3167,17 @@ class SparseNullsOperationInput: sparse_string_map: dict[str, str | None] | None = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT).members_by_index if self.sparse_string_list is not None: _serialize_sparse_string_list( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members["sparseStringList"], - self.sparse_string_list, + serializer, members[0], self.sparse_string_list ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[1], self.sparse_string_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3771,29 +3186,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_string_list"] = _deserialize_sparse_string_list( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members[ - "sparseStringList" - ], + de, members[0] ) case 1: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT.members["sparseStringMap"], + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SPARSE_NULLS_OPERATION_INPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3817,22 +3228,17 @@ class SparseNullsOperationOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT).members_by_index if self.sparse_string_list is not None: _serialize_sparse_string_list( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members["sparseStringList"], - self.sparse_string_list, + serializer, members[0], self.sparse_string_list ) if self.sparse_string_map is not None: - _serialize_sparse_string_map( - serializer, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members["sparseStringMap"], - self.sparse_string_map, - ) + _serialize_sparse_string_map(serializer, members[1], self.sparse_string_map) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3841,43 +3247,34 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["sparse_string_list"] = _deserialize_sparse_string_list( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members[ - "sparseStringList" - ], + de, members[0] ) case 1: kwargs["sparse_string_map"] = _deserialize_sparse_string_map( - de, - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT.members[ - "sparseStringMap" - ], + de, members[1] ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs SPARSE_NULLS_OPERATION = APIOperation( input=SparseNullsOperationInput, output=SparseNullsOperationOutput, - schema=_SCHEMA_SPARSE_NULLS_OPERATION, - input_schema=_SCHEMA_SPARSE_NULLS_OPERATION_INPUT, - output_schema=_SCHEMA_SPARSE_NULLS_OPERATION_OUTPUT, + static_schema=_SCHEMA_SPARSE_NULLS_OPERATION, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) @@ -3890,19 +3287,19 @@ class RecursiveShapesInputOutputNested1: nested: "RecursiveShapesInputOutputNested2 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 + ).members_by_index if self.foo is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["foo"], self.foo - ) + serializer.write_string(members[0], self.foo) if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["nested"], - self.nested, - ) + serializer.write_struct(members[1], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3911,23 +3308,21 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["foo"] = de.read_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1.members["foo"] - ) + kwargs["foo"] = de.read_string(members[0]) case 1: kwargs["nested"] = RecursiveShapesInputOutputNested2.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3940,21 +3335,19 @@ class RecursiveShapesInputOutputNested2: recursive_member: "RecursiveShapesInputOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, self) + serializer.write_struct( + hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2), self + ) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate( + _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 + ).members_by_index if self.bar is not None: - serializer.write_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members["bar"], self.bar - ) + serializer.write_string(members[0], self.bar) if self.recursive_member is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members[ - "recursiveMember" - ], - self.recursive_member, - ) + serializer.write_struct(members[1], self.recursive_member) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -3963,13 +3356,13 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: - kwargs["bar"] = de.read_string( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2.members["bar"] - ) + kwargs["bar"] = de.read_string(members[0]) case 1: kwargs["recursive_member"] = ( @@ -3977,11 +3370,9 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: ) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, consumer=_consumer - ) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -3992,13 +3383,12 @@ class RecursiveShapesInput: nested: "RecursiveShapesInputOutputNested1 | None" = None def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_INPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4007,16 +3397,18 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_INPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveShapesInputOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_SHAPES_INPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs @@ -4038,13 +3430,12 @@ class RecursiveShapesOutput: """ def serialize(self, serializer: ShapeSerializer): - serializer.write_struct(_SCHEMA_RECURSIVE_SHAPES_OUTPUT, self) + serializer.write_struct(hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT), self) def serialize_members(self, serializer: ShapeSerializer): + members = hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT).members_by_index if self.nested is not None: - serializer.write_struct( - _SCHEMA_RECURSIVE_SHAPES_OUTPUT.members["nested"], self.nested - ) + serializer.write_struct(members[0], self.nested) @classmethod def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @@ -4053,26 +3444,25 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: ShapeDeserializer) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = hydrate(_SCHEMA_RECURSIVE_SHAPES_OUTPUT) + members = schema.members_by_index - def _consumer(schema: Schema, de: ShapeDeserializer) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: Schema, de: ShapeDeserializer) -> None: + match member_schema.expect_member_index(): case 0: kwargs["nested"] = RecursiveShapesInputOutputNested1.deserialize(de) case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct(_SCHEMA_RECURSIVE_SHAPES_OUTPUT, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) return kwargs RECURSIVE_SHAPES = APIOperation( input=RecursiveShapesInput, output=RecursiveShapesOutput, - schema=_SCHEMA_RECURSIVE_SHAPES, - input_schema=_SCHEMA_RECURSIVE_SHAPES_INPUT, - output_schema=_SCHEMA_RECURSIVE_SHAPES_OUTPUT, + static_schema=_SCHEMA_RECURSIVE_SHAPES, error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java index 93e29a4b4..a676440a2 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java @@ -23,6 +23,10 @@ public final class RuntimeTypes { public static final Symbol API_OPERATION = createSymbol("schemas", "APIOperation", SmithyPythonDependency.SMITHY_CORE); + // smithy_core._schema_compact + public static final Symbol HYDRATE = + createSymbol("_schema_compact", "hydrate", SmithyPythonDependency.SMITHY_CORE); + // smithy_core.shapes public static final Symbol SHAPE_ID = createSymbol("shapes", "ShapeID", SmithyPythonDependency.SMITHY_CORE); public static final Symbol SHAPE_TYPE = createSymbol("shapes", "ShapeType", SmithyPythonDependency.SMITHY_CORE); diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/ListGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/ListGenerator.java index f5026914e..21ca54502 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/ListGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/ListGenerator.java @@ -42,7 +42,7 @@ private void generateSerializer() { var memberTarget = context.model().expectShape(shape.getMember().getTarget()); writer.write(""" def $1L(serializer: $2T, schema: $3T, value: $4T) -> None: - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] with serializer.begin_list(schema, len(value)) as ls: for e in value: ${?sparse} @@ -79,7 +79,7 @@ private void generateDeserializer() { def $1L(deserializer: $2T, schema: $3T) -> $4T: result: $4T = [] ${?includeSchema} - member_schema = schema.members["member"] + member_schema = schema.members_by_index[0] ${/includeSchema} def _read_value(d: $2T): if d.is_null(): diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MapGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MapGenerator.java index cf65a83c7..3bd5cd9e3 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MapGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MapGenerator.java @@ -46,7 +46,7 @@ private void generateSerializer() { writer.write(""" def $1L(serializer: $2T, schema: $3T, value: $4T) -> None: with serializer.begin_map(schema, len(value)) as m: - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] for k, v in value.items(): ${?sparse} if v is None: @@ -80,7 +80,7 @@ private void generateDeserializer() { writer.write(""" def $1L(deserializer: $2T, schema: $3T) -> $4T: result: $4T = {} - value_schema = schema.members["value"] + value_schema = schema.members_by_index[1] def _read_value(k: str, d: $2T): if d.is_null(): d.read_null() diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java index 8e763cf87..fcd0bcaea 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java @@ -95,10 +95,21 @@ private void writeSchema() { } else if (parent.isMapShape()) { writer.writeInline("value_schema"); } else { - writer.writeInline("${schema:T}.members[${member:S}]"); + writer.writeInline("members[$L]", Integer.toString(memberIndex(parent))); } } + private int memberIndex(Shape parent) { + int index = 0; + for (var m : parent.members()) { + if (m.getMemberName().equals(member.getMemberName())) { + return index; + } + index++; + } + throw new CodegenException("Member not found in container: " + member.getId()); + } + @Override public Void blobShape(BlobShape shape) { if (shape.hasTrait(StreamingTrait.class)) { diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java index 2dd110d8f..40a395dfc 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java @@ -102,10 +102,21 @@ private void writeSchema() { } else if (parent.isMapShape()) { writer.writeInline("value_schema"); } else { - writer.writeInline("${schema:T}.members[${member:S}]"); + writer.writeInline("members[$L]", Integer.toString(memberIndex(parent))); } } + private int memberIndex(Shape parent) { + int index = 0; + for (var m : parent.members()) { + if (m.getMemberName().equals(member.getMemberName())) { + return index; + } + index++; + } + throw new CodegenException("Member not found in container: " + member.getId()); + } + @Override public Void blobShape(BlobShape shape) { if (shape.hasTrait(StreamingTrait.class)) { diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/OperationGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/OperationGenerator.java index 65386f33f..53f627f09 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/OperationGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/OperationGenerator.java @@ -50,18 +50,13 @@ public void run() { $1L = $2T( input = $3T, output = $4T, - schema = $5T, - input_schema = $6T, - output_schema = $7T, - error_registry = $8T({ - $9C + static_schema = $5T, + error_registry = $6T({ + $7C }), effective_auth_schemes = [ - ${10C} + ${8C} ], - error_schemas = [ - ${11C} - ] ) """, opSymbol.getName(), @@ -69,12 +64,9 @@ public void run() { inSymbol, outSymbol, opSymbol.expectProperty(SymbolProperties.SCHEMA), - inSymbol.expectProperty(SymbolProperties.SCHEMA), - outSymbol.expectProperty(SymbolProperties.SCHEMA), RuntimeTypes.TYPE_REGISTRY, writer.consumer(this::writeErrorTypeRegistry), - writer.consumer(this::writeAuthSchemes), - writer.consumer(this::writeErrorSchemas)); + writer.consumer(this::writeAuthSchemes)); } private void writeErrorTypeRegistry(PythonWriter writer) { @@ -85,13 +77,6 @@ private void writeErrorTypeRegistry(PythonWriter writer) { } } - private void writeErrorSchemas(PythonWriter writer) { - for (var error : shape.getErrors()) { - var errSymbol = symbolProvider.toSymbol(model.expectShape(error)); - writer.write("$T,", errSymbol.expectProperty(SymbolProperties.SCHEMA)); - } - } - private void writeAuthSchemes(PythonWriter writer) { var authSchemes = ServiceIndex.of(model) .getEffectiveAuthSchemes(context.settings().service(), diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java index 8e0c4b349..8f23e0d7e 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java @@ -4,54 +4,101 @@ */ package software.amazon.smithy.python.codegen.generators; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; -import java.util.Comparator; import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; -import java.util.TreeMap; import java.util.function.Consumer; import java.util.function.Function; -import java.util.logging.Logger; import java.util.stream.Collectors; import java.util.stream.Stream; -import software.amazon.smithy.codegen.core.Symbol; import software.amazon.smithy.codegen.core.TopologicalIndex; import software.amazon.smithy.model.loader.Prelude; import software.amazon.smithy.model.node.Node; import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.OperationShape; import software.amazon.smithy.model.shapes.Shape; import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.ShapeType; import software.amazon.smithy.model.traits.UnitTypeTrait; import software.amazon.smithy.python.codegen.GenerationContext; -import software.amazon.smithy.python.codegen.RuntimeTypes; import software.amazon.smithy.python.codegen.SchemaTraitFilterIndex; -import software.amazon.smithy.python.codegen.SmithyPythonDependency; import software.amazon.smithy.python.codegen.SymbolProperties; import software.amazon.smithy.python.codegen.writer.PythonWriter; -import software.amazon.smithy.utils.CaseUtils; import software.amazon.smithy.utils.SmithyUnstableApi; /** - * Generates schemas for shapes. + * Generates compact, tuple-encoded schemas for shapes. * - *

Schemas are essentially a reduced, runtime-available model. + *

Each shape is emitted as pure data: a module global bound to a positional tuple + * led by its {@link ShapeType} integer (see {@code smithy_core._schema_compact}). + * Repeated strings are interned into short module constants, prelude member targets + * collapse to their type integer, and valueless two-state traits collapse into a + * single integer bit-vector. Nothing is materialized at import; generated code calls + * {@code hydrate(TUPLE)} to build the real {@code Schema} on first use. A member + * target that points at a shape not yet defined in file order is emitted as a + * {@code lambda} so the forward/recursive reference resolves lazily. */ @SmithyUnstableApi public final class SchemaGenerator implements Consumer { - private static final Logger LOGGER = Logger.getLogger(SchemaGenerator.class.getName()); - private static final Symbol UNIT_SYMBOL = Symbol.builder() - .name("UNIT") - .namespace("smithy_core.prelude", ".") - .addDependency(SmithyPythonDependency.SMITHY_CORE) - .build(); + // Bit index -> trait id. MUST match smithy_core._schema_compact._TRAIT_BITS. + private static final List TRAIT_BITS = List.of( + "smithy.api#required", + "smithy.api#idempotencyToken", + "smithy.api#sensitive", + "smithy.api#httpLabel", + "smithy.api#httpPayload", + "smithy.api#idempotent", + "smithy.api#sparse", + "smithy.api#httpResponseCode", + "smithy.api#hostLabel", + "smithy.api#requiresLength", + "smithy.api#httpQueryParams", + "smithy.api#notProperty"); + + // Prelude shape id -> its ShapeType integer substitute. Matches _PRELUDE. + private static final Map PRELUDE_INTS = Map.ofEntries( + Map.entry("smithy.api#Blob", 1), + Map.entry("smithy.api#Boolean", 2), + Map.entry("smithy.api#String", 3), + Map.entry("smithy.api#Timestamp", 4), + Map.entry("smithy.api#Byte", 5), + Map.entry("smithy.api#Short", 6), + Map.entry("smithy.api#Integer", 7), + Map.entry("smithy.api#Long", 8), + Map.entry("smithy.api#Float", 9), + Map.entry("smithy.api#Double", 10), + Map.entry("smithy.api#BigInteger", 11), + Map.entry("smithy.api#BigDecimal", 12), + Map.entry("smithy.api#Document", 13), + Map.entry("smithy.api#PrimitiveBoolean", 2), + Map.entry("smithy.api#PrimitiveByte", 5), + Map.entry("smithy.api#PrimitiveShort", 6), + Map.entry("smithy.api#PrimitiveInteger", 7), + Map.entry("smithy.api#PrimitiveLong", 8), + Map.entry("smithy.api#PrimitiveFloat", 9), + Map.entry("smithy.api#PrimitiveDouble", 10)); + + private static final int UNIT_INT = -1; private final GenerationContext context; - private final Set generatedShapes = new HashSet<>(); - private final Map deferredMembers = - new TreeMap<>(Comparator.comparing(MemberShape::getId)); + + // Shapes already emitted in file order; a target not yet here is a forward ref. + private final Set written = new HashSet<>(); + + // Interned string -> short constant symbol (StringStore). + private final Map stringStore = new LinkedHashMap<>(); + + // Variable names already handed out, for collision detection across both the + // initialism and preferred-prefix allocation paths. + private final Set allocated = new HashSet<>(); public SchemaGenerator(GenerationContext context) { this.context = context; @@ -59,13 +106,7 @@ public SchemaGenerator(GenerationContext context) { @Override public void accept(Shape shape) { - var symbol = context.symbolProvider().toSymbol(shape).expectProperty(SymbolProperties.SCHEMA).getSymbol(); - context.writerDelegator() - .useFileWriter( - symbol.getDefinitionFile(), - symbol.getNamespace(), - writer -> writeShapeSchema(writer, shape)); - generatedShapes.add(shape.getId()); + // Collection happens in generateAll's single pass. } public static void generateAll( @@ -73,186 +114,328 @@ public static void generateAll( Collection shapes, Function filter ) { - var schemaGenerator = new SchemaGenerator(context); + var generator = new SchemaGenerator(context); var index = TopologicalIndex.of(context.model()); - Stream.concat(index.getOrderedShapes().stream(), index.getRecursiveShapes().stream()) + var ordered = Stream.concat( + index.getOrderedShapes().stream(), + index.getRecursiveShapes().stream()) .filter(shapes::contains) .filter(shape -> !shape.isResourceShape() && !shape.isMemberShape() && !Prelude.isPreludeShape(shape)) .filter(filter::apply) - .forEach(schemaGenerator); - schemaGenerator.finalizeRecursiveShapes(); + .collect(Collectors.toList()); + generator.writeFile(ordered); } public static void generateAll(GenerationContext context, Collection shapes) { SchemaGenerator.generateAll(context, shapes, s -> true); } - private void writeShapeSchema(PythonWriter writer, Shape shape) { - writer.pushState(); + private void writeFile(List shapes) { + var filename = String.format("src/%s/_private/schemas.py", context.settings().moduleName()); + var namespace = String.format("%s._private.schemas", context.settings().moduleName()); - var symbol = context.symbolProvider().toSymbol(shape).expectProperty(SymbolProperties.SCHEMA).getSymbol(); - writer.addLocallyDefinedSymbol(symbol); + for (var shape : shapes) { + intern(shape.getId().getNamespace(), "n"); + intern(shape.getId().getName()); + internTraitStrings(filterTraits(shape)); + for (var member : shape.members()) { + intern(member.getMemberName()); + internTraitStrings(filterTraits(member)); + } + } - var traits = filterTraits(shape); - writer.putContext("isCollection", shape.isStructureShape() || !shape.members().isEmpty()); - writer.putContext("isStructure", shape.isStructureShape()); - writer.putContext("shapeType", CaseUtils.toSnakeCase(shape.getType().toString()).toUpperCase()); - writer.putContext("hasTraits", !traits.isEmpty()); - - writer.write(""" - $1L = $2T${?isCollection}.collection${/isCollection}( - id=$3T($4S), - ${^isStructure}shape_type=$5T.${shapeType:L},${/isStructure} - ${?hasTraits} - traits=[ - ${6C|} - ], - ${/hasTraits} - ${7C|} - ) - """, - symbol.getName(), - RuntimeTypes.SCHEMA, - RuntimeTypes.SHAPE_ID, - shape.getId(), - RuntimeTypes.SHAPE_TYPE, - writer.consumer(w -> writeTraits(w, traits)), - writer.consumer(w -> writeSchemaMembers(w, shape))); - writer.popState(); + context.writerDelegator().useFileWriter(filename, namespace, writer -> { + writeStringStore(writer); + for (var shape : shapes) { + writeShape(writer, shape); + } + }); } - private Map> filterTraits(Shape shape) { - var traitFilter = SchemaTraitFilterIndex.of(context.model()); - return shape.getAllTraits() - .entrySet() - .stream() - .filter(t -> traitFilter.includeTrait(t.getKey())) - .collect(Collectors.toMap(Map.Entry::getKey, e -> { - var value = e.getValue().toNode(); - if (value.isObjectNode() && value.asObjectNode().get().getMembers().isEmpty()) { - return Optional.empty(); - } - return Optional.of(value); - })); + // String interning follows smithy-typescript's StringStore: a general literal + // becomes `_` + its initials (uppercase/word-start letters), deconflicted with its + // remaining letters; namespaces use a preferred `n{N}` prefix since they repeat + // heavily and carry no useful initials. + private String intern(String value) { + return stringStore.computeIfAbsent(value, this::allocateVariable); } - private void writeTraits(PythonWriter writer, Map> traits) { - writer.pushState(); - writer.putContext("traits", traits); - writer.write(""" - ${#traits} - $1T.new(id=$2T(${key:S})${?value}, value=${value:N}${/value}), - ${/traits}""", - RuntimeTypes.TRAIT, - RuntimeTypes.SHAPE_ID); - writer.popState(); + private String intern(String value, String preferredPrefix) { + return stringStore.computeIfAbsent(value, v -> assignPreferredKey(v, preferredPrefix)); } - private void writeSchemaMembers(PythonWriter writer, Shape shape) { - if (shape.members().isEmpty()) { - return; + private String assignPreferredKey(String literal, String preferredPrefix) { + int suffix = 0; + var candidate = preferredPrefix + suffix; + while (allocated.contains(candidate)) { + candidate = preferredPrefix + (++suffix); } + allocated.add(candidate); + return candidate; + } - writer.openBlock("members={", "}", () -> { - int index = 0; - for (MemberShape member : shape.members()) { - if (!generatedShapes.contains(member.getTarget()) && !Prelude.isPreludeShape(member.getTarget())) { - deferredMembers.put(member, index++); - writer.write(""" - # This needs to reference a schema that isn't defined yet. - # It will be populated with a non-null value at the end of the file. - $S: None, - """, member.getMemberName()); - continue; + // Mirrors StringStore.allocateVariable: initials from word-split sections, or the + // uppercase (and leading, while still neutral) letters of a single CamelCase word, + // with the rest queued to break collisions. + private String allocateVariable(String literal) { + var sections = Arrays.stream(literal.split("[-_\\s]")) + .filter(s -> !s.isEmpty()) + .toArray(String[]::new); + var v = new StringBuilder("_"); + var deconfliction = new ArrayDeque(); + if (sections.length > 1) { + for (var s : sections) { + char c = s.charAt(0); + if (isAllowedChar(c)) { + v.append(c); } - - writer.pushState(); - var traits = filterTraits(member); - writer.putContext("hasTraits", !traits.isEmpty()); - - // For some reason the unit shape is being stripped from the model, despite the fact that - // it's referenced. - Symbol targetSchemaSymbol; - if (member.getTarget().equals(UnitTypeTrait.UNIT)) { - targetSchemaSymbol = UNIT_SYMBOL; - } else { - var targetSymbol = context.symbolProvider() - .toSymbol(context.model().expectShape(member.getTarget())); - targetSchemaSymbol = targetSymbol.expectProperty(SymbolProperties.SCHEMA).getSymbol(); + } + } else { + for (int i = 0; i < literal.length(); i++) { + char c = literal.charAt(i); + if ((c >= 'A' && c <= 'Z') || (isNeutral(v.toString()) && isAllowedChar(c))) { + v.append(c); + } else if (isAllowedChar(c)) { + deconfliction.add(c); } + } + } + if (v.length() == 1) { + v.append("v"); + } + while (allocated.contains(v.toString())) { + v.append(deconfliction.isEmpty() ? '_' : deconfliction.poll()); + } + allocated.add(v.toString()); + return v.toString(); + } + + private boolean isAllowedChar(char c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); + } + + private boolean isNeutral(String variable) { + for (int i = 0; i < variable.length(); i++) { + if (variable.charAt(i) != '_') { + return false; + } + } + return true; + } + + private void internTraitStrings(Map> traits) { + for (var entry : traits.entrySet()) { + intern(entry.getKey().toString()); + var value = entry.getValue(); + if (value.isPresent() && value.get().isStringNode()) { + intern(value.get().expectStringNode().getValue()); + } + } + } + + private void writeStringStore(PythonWriter writer) { + for (var entry : stringStore.entrySet()) { + writer.write("$L = $S", entry.getValue(), entry.getKey()); + } + writer.write(""); + } + + private void writeShape(PythonWriter writer, Shape shape) { + var nsConst = stringStore.get(shape.getId().getNamespace()); + var nameConst = stringStore.get(shape.getId().getName()); + var traits = filterTraits(shape); + int typeInt = typeInt(shape); + var key = schemaName(shape); + + writer.writeInline("$L = ($L, $L, $L, ", key, Integer.toString(typeInt), nsConst, nameConst); + writeTraits(writer, traits); - writer.write(""" - $S: { - "target": $T, - ${?hasTraits} - "traits": [ - ${C|} - ], - ${/hasTraits} - }, - """, - member.getMemberName(), - targetSchemaSymbol, - writer.consumer(w -> writeTraits(w, traits))); - - index++; - writer.popState(); + if (shape.isOperationShape()) { + writeOperationRefs(writer, shape.asOperationShape().get()); + writer.write(")"); + writer.write(""); + written.add(shape.getId()); + return; + } + + if (shape.members().isEmpty()) { + writer.write(")"); + writer.write(""); + written.add(shape.getId()); + return; + } + + writer.write(","); + writer.write("($L),", memberNameTuple(shape)); + writer.openBlock("(", "),", () -> writeMemberTargets(writer, shape)); + writer.write(")"); + writer.write(""); + written.add(shape.getId()); + } + + // Operation tuple trailing slots: input_ref, output_ref, (error_refs...). Matches + // _schema_compact._OP_INPUT / _OP_OUTPUT / _OP_ERRORS. + private void writeOperationRefs(PythonWriter writer, OperationShape op) { + writer.write(","); + writer.writeInline(""); + writeSchemaRef(writer, op.getInputShape()); + writer.write(","); + writer.writeInline(""); + writeSchemaRef(writer, op.getOutputShape()); + writer.write(","); + writer.openBlock("(", ")", () -> { + for (var error : op.getErrors()) { + writer.writeInline(""); + writeSchemaRef(writer, error); + writer.write(","); } }); } - // Some shapes have members that refer to themselves, or members that refer to other - // shapes that then refer back to them. In typing we can get around that with forward - // references, but when generating schemas we need to instead defer creating those - // members until all schemas exist. - public void finalizeRecursiveShapes() { - var filename = String.format("src/%s/_private/schemas.py", context.settings().moduleName()); - var namespace = String.format("%s._private.schemas", context.settings().moduleName()); - context.writerDelegator().useFileWriter(filename, namespace, this::finalizeRecursiveShapes); + private String schemaName(Shape shape) { + return context.symbolProvider() + .toSymbol(shape) + .expectProperty(SymbolProperties.SCHEMA) + .getSymbol() + .getName(); + } + + private String memberNameTuple(Shape shape) { + var names = new ArrayList(); + for (var member : shape.members()) { + names.add(stringStore.get(member.getMemberName())); + } + return names.isEmpty() ? "" : String.join(", ", names) + ","; + } + + private void writeMemberTargets(PythonWriter writer, Shape shape) { + for (var member : shape.members()) { + writer.writeInline(""); + writeMemberTarget(writer, member); + writer.write(","); + } } - private void finalizeRecursiveShapes(PythonWriter writer) { - for (Map.Entry entry : deferredMembers.entrySet()) { - var member = entry.getKey(); - LOGGER.warning("Generating member: " + member.getId()); - var container = context.symbolProvider() - .toSymbol(context.model().expectShape(member.getContainer())) - .expectProperty(SymbolProperties.SCHEMA) - .getSymbol(); - var target = context.symbolProvider() - .toSymbol(context.model().expectShape(member.getTarget())) - .expectProperty(SymbolProperties.SCHEMA) - .getSymbol(); - - writer.pushState(); - var traits = filterTraits(member); - writer.putContext("hasTraits", !traits.isEmpty()); - - writer.write(""" - $1T.members[$2S] = $6T.member( - id=$1T.id.with_member($2S), - target=$3T, - index=$5L, - ${?hasTraits} - member_traits=[ - ${4C|} - ], - ${/hasTraits} - ) - - """, - container, - member.getMemberName(), - target, - writer.consumer(w -> writeTraits(w, traits)), - entry.getValue(), - RuntimeTypes.SCHEMA); - - writer.popState(); + private void writeMemberTarget(PythonWriter writer, MemberShape member) { + var memberTraits = filterTraits(member); + writer.writeInline("("); + writeSchemaRef(writer, member.getTarget()); + writer.writeInline(", "); + writeTraits(writer, memberTraits); + writer.writeInline(")"); + } + + // Emits a reference to another shape's schema: a prelude int / UNIT sentinel for + // prelude targets, a bare sibling symbol when already defined above (folds as a + // constant), else a lambda for a forward or recursive reference. + private void writeSchemaRef(PythonWriter writer, ShapeId target) { + if (target.equals(UnitTypeTrait.UNIT)) { + writer.writeInline("$L", Integer.toString(UNIT_INT)); + } else if (PRELUDE_INTS.containsKey(target.toString())) { + writer.writeInline("$L", Integer.toString(PRELUDE_INTS.get(target.toString()))); + } else { + var targetName = schemaName(context.model().expectShape(target)); + if (written.contains(target)) { + writer.writeInline("$L", targetName); + } else { + writer.writeInline("lambda: $L", targetName); + } + } + } + + /** + * Writes the compact trait literal: an int bit-vector when every trait is a + * valueless two-state trait, otherwise a dict of interned id -> value (also + * carrying any valueless traits present). + */ + private void writeTraits(PythonWriter writer, Map> traits) { + if (traits.isEmpty()) { + writer.writeInline("0"); + return; + } + + int bits = 0; + var valued = new LinkedHashMap>(); + var valuelessKnown = new ArrayList(); + for (var entry : traits.entrySet()) { + var id = entry.getKey().toString(); + int bitIndex = TRAIT_BITS.indexOf(id); + if (bitIndex >= 0 && entry.getValue().isEmpty()) { + bits |= (1 << bitIndex); + valuelessKnown.add(id); + } else { + valued.put(entry.getKey(), entry.getValue()); + } } - deferredMembers.clear(); + if (valued.isEmpty()) { + writer.writeInline("$L", Integer.toString(bits)); + return; + } + + writer.writeInline("{"); + boolean first = true; + for (var entry : valued.entrySet()) { + if (!first) { + writer.writeInline(", "); + } + first = false; + writer.writeInline("$L: ", stringStore.get(entry.getKey().toString())); + if (entry.getValue().isEmpty()) { + writer.writeInline("None"); + } else if (entry.getValue().get().isStringNode()) { + writer.writeInline("$L", stringStore.get(entry.getValue().get().expectStringNode().getValue())); + } else { + writer.writeInline("$N", entry.getValue().get()); + } + } + for (var id : valuelessKnown) { + writer.writeInline(", $L: None", stringStore.get(id)); + } + writer.writeInline("}"); + } + + private Map> filterTraits(Shape shape) { + var traitFilter = SchemaTraitFilterIndex.of(context.model()); + return shape.getAllTraits() + .entrySet() + .stream() + .filter(t -> traitFilter.includeTrait(t.getKey())) + .collect(Collectors.toMap(Map.Entry::getKey, e -> { + var value = e.getValue().toNode(); + if (value.isObjectNode() && value.asObjectNode().get().getMembers().isEmpty()) { + return Optional.empty(); + } + return Optional.of(value); + })); + } + + private int typeInt(Shape shape) { + return switch (shape.getType()) { + case BLOB -> 1; + case BOOLEAN -> 2; + case STRING -> 3; + case TIMESTAMP -> 4; + case BYTE -> 5; + case SHORT -> 6; + case INTEGER -> 7; + case LONG -> 8; + case FLOAT -> 9; + case DOUBLE -> 10; + case BIG_INTEGER -> 11; + case BIG_DECIMAL -> 12; + case DOCUMENT -> 13; + case ENUM -> 14; + case INT_ENUM -> 15; + case LIST, SET -> 16; + case MAP -> 17; + case STRUCTURE -> 18; + case UNION -> 19; + case SERVICE -> 21; + case OPERATION -> 23; + default -> 3; + }; } } diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java index eda45fc54..52d1f98cc 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java @@ -171,6 +171,10 @@ private static void writePyproject( reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false + reportUnknownVariableType = false + reportUnknownMemberType = false + reportUnknownArgumentType = false + reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/StructureGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/StructureGenerator.java index 07e0a57ed..d0f7e6dd9 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/StructureGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/StructureGenerator.java @@ -376,9 +376,10 @@ private void generateSerializeMethod() { writer.putContext("shapeSerializer", RuntimeTypes.SHAPE_SERIALIZER); writer.putContext("schema", symbolProvider.toSymbol(shape).expectProperty(SymbolProperties.SCHEMA)); + writer.putContext("hydrate", RuntimeTypes.HYDRATE); writer.write(""" def serialize(self, serializer: ${shapeSerializer:T}): - serializer.write_struct(${schema:T}, self) + serializer.write_struct(${hydrate:T}(${schema:T}), self) """); @@ -387,6 +388,7 @@ def serialize(self, serializer: ${shapeSerializer:T}): if (serializeableMembers.isEmpty()) { writer.write("pass"); } else { + writer.write("members = ${hydrate:T}(${schema:T}).members_by_index"); for (MemberShape member : serializeableMembers) { writer.pushState(); var target = model.expectShape(member.getTarget()); @@ -435,6 +437,15 @@ private void generateDeserializeMethod() { var corrections = errorCorrections(); writer.putContext("errorCorrection", !corrections.isEmpty()); + // A struct with no (non-streaming) members emits no case arms, so the member + // index tuple would be an unused local. + boolean hasMembers = shape.members() + .stream() + .anyMatch(m -> { + var t = model.expectShape(m.getTarget()); + return !(t.hasTrait(StreamingTrait.class) && t.isUnionShape()); + }); + writer.putContext("hasMembers", hasMembers); // TODO: either formalize deserialize_kwargs or remove it when http serde is converted writer.write(""" @@ -445,14 +456,18 @@ def deserialize(cls, deserializer: $1T) -> Self: @classmethod def deserialize_kwargs(cls, deserializer: $1T) -> dict[str, Any]: kwargs: dict[str, Any] = {} + schema = $6T($4T) + ${?hasMembers} + members = schema.members_by_index + ${/hasMembers} - def _consumer(schema: $2T, de: $1T) -> None: - match schema.expect_member_index(): + def _consumer(member_schema: $2T, de: $1T) -> None: + match member_schema.expect_member_index(): ${3C|} case _: - logger.debug("Unexpected member schema: %s", schema) + logger.debug("Unexpected member schema: %s", member_schema) - deserializer.read_struct($4T, consumer=_consumer) + deserializer.read_struct(schema, consumer=_consumer) ${?errorCorrection} ${5C|} ${/errorCorrection} @@ -463,7 +478,8 @@ def _consumer(schema: $2T, de: $1T) -> None: RuntimeTypes.SCHEMA, writer.consumer(w -> deserializeMembers(shape.members())), schemaSymbol, - writer.consumer(w -> writeErrorCorrection(corrections))); + writer.consumer(w -> writeErrorCorrection(corrections)), + RuntimeTypes.HYDRATE); writer.popState(); } diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/UnionGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/UnionGenerator.java index 1cd2c62ea..a003c8b00 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/UnionGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/UnionGenerator.java @@ -59,6 +59,7 @@ public void run() { writer.putContext("serializationError", RuntimeTypes.SERIALIZATION_ERROR); var schemaSymbol = symbolProvider.toSymbol(shape).expectProperty(SymbolProperties.SCHEMA); writer.putContext("schema", schemaSymbol); + writer.putContext("hydrate", RuntimeTypes.HYDRATE); var memberNames = new ArrayList(); for (MemberShape member : shape.members()) { @@ -70,6 +71,9 @@ public void run() { var targetSymbol = symbolProvider.toSymbol(target); writer.pushState(); writer.putContext("quote", recursiveShapes.contains(target) ? "'" : ""); + // struct/union variant targets deserialize via their own classmethod and + // never touch the member schema, so hoisting it would be an unused local. + writer.putContext("deserUsesSchema", !target.isStructureShape() && !target.isUnionShape()); writer.write(""" @dataclass class $1L: @@ -78,14 +82,18 @@ class $1L: value: ${quote:L}$3T${quote:L} def serialize(self, serializer: ${shapeSerializer:T}): - serializer.write_struct($4T, self) + serializer.write_struct(${hydrate:T}(${schema:T}), self) def serialize_members(self, serializer: ${shapeSerializer:T}): - ${5C|} + members = ${hydrate:T}(${schema:T}).members_by_index + ${4C|} @classmethod def deserialize(cls, deserializer: ${shapeDeserializer:T}) -> Self: - return cls(value=${6C|}) + ${?deserUsesSchema} + members = ${hydrate:T}(${schema:T}).members_by_index + ${/deserUsesSchema} + return cls(value=${5C|}) """, memberSymbol.getName(), @@ -93,7 +101,6 @@ def deserialize(cls, deserializer: ${shapeDeserializer:T}) -> Self: .map(StringTrait::getValue) .ifPresent(docs -> w.writeDocs(docs, context))), targetSymbol, - schemaSymbol, writer.consumer(w -> target.accept( new MemberSerializerGenerator(context, w, member, "serializer"))), writer.consumer(w -> target.accept( @@ -157,6 +164,7 @@ private void generateDeserializer() { var schemaSymbol = symbol.expectProperty(SymbolProperties.SCHEMA); var unknownSymbol = symbol.expectProperty(SymbolProperties.UNION_UNKNOWN); writer.putContext("schema", schemaSymbol); + writer.putContext("hydrate", RuntimeTypes.HYDRATE); writer.write( """ class $1L: @@ -164,7 +172,7 @@ class $1L: def deserialize(self, deserializer: ${shapeDeserializer:T}) -> $2T: self._result = None - deserializer.read_struct($3T, self._consumer) + deserializer.read_struct(${hydrate:T}($3T), self._consumer) if self._result is None: raise ${serializationError:T}("Unions must have exactly one value, but found none.") diff --git a/packages/smithy-aws-core/tests/unit/aio/test_protocols.py b/packages/smithy-aws-core/tests/unit/aio/test_protocols.py index cff8349b3..9718f560c 100644 --- a/packages/smithy-aws-core/tests/unit/aio/test_protocols.py +++ b/packages/smithy-aws-core/tests/unit/aio/test_protocols.py @@ -25,7 +25,7 @@ from smithy_core.schemas import APIOperation, Schema from smithy_core.serializers import ShapeSerializer from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import HTTPTrait, Trait +from smithy_core.traits import Trait from smithy_core.types import TypedProperties from smithy_http import Fields, tuples_to_fields from smithy_http.aio import HTTPRequest, HTTPResponse @@ -791,16 +791,17 @@ def _rest_xml_operation() -> APIOperation[Any, Any]: return APIOperation( input=_EmptyInput, output=_EmptyOutput, - schema=Schema( - id=ShapeID("com.test#GetThing"), - shape_type=ShapeType.OPERATION, - traits=[HTTPTrait({"method": "GET", "code": 200, "uri": "/"})], + static_schema=( + ShapeType.OPERATION.value, + "com.test", + "GetThing", + {"smithy.api#http": {"method": "GET", "code": 200, "uri": "/"}}, + _EMPTY_INPUT_SCHEMA, + _EMPTY_OUTPUT_SCHEMA, + (_NO_SUCH_BUCKET_SCHEMA,), ), - input_schema=_EMPTY_INPUT_SCHEMA, - output_schema=_EMPTY_OUTPUT_SCHEMA, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[_NO_SUCH_BUCKET_SCHEMA], ) diff --git a/packages/smithy-cbor/tests/benchmark/model.py b/packages/smithy-cbor/tests/benchmark/model.py index 0e9ed024d..66defc8ea 100644 --- a/packages/smithy-cbor/tests/benchmark/model.py +++ b/packages/smithy-cbor/tests/benchmark/model.py @@ -91,11 +91,6 @@ members={"records": {"target": RECORD_LIST}}, ) -PUT_RECORDS = Schema( - id=ShapeID(f"{_NS}#PutRecords"), - shape_type=ShapeType.OPERATION, -) - SERVICE = Schema( id=ShapeID(f"{_NS}#BenchmarkService"), shape_type=ShapeType.SERVICE, @@ -356,10 +351,15 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None: PUT_RECORDS_OPERATION: APIOperation[PutRecordsInput, PutRecordsOutput] = APIOperation( input=PutRecordsInput, output=PutRecordsOutput, - schema=PUT_RECORDS, - input_schema=PUT_RECORDS_INPUT, - output_schema=PUT_RECORDS_OUTPUT, + static_schema=( + ShapeType.OPERATION.value, + _NS, + "PutRecords", + 0, + PUT_RECORDS_INPUT, + PUT_RECORDS_OUTPUT, + (), + ), error_registry=TypeRegistry({}), effective_auth_schemes=[ShapeID("smithy.api#noAuth")], - error_schemas=[], ) diff --git a/packages/smithy-core/src/smithy_core/_schema_compact.py b/packages/smithy-core/src/smithy_core/_schema_compact.py new file mode 100644 index 000000000..2161b1792 --- /dev/null +++ b/packages/smithy-core/src/smithy_core/_schema_compact.py @@ -0,0 +1,231 @@ +# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 +"""On-demand hydration of compact, tuple-encoded schemas. + +Generated ``_private/schemas.py`` files are pure data: each shape is bound to a +module global holding a positional tuple led by its :py:class:`ShapeType` integer. +No :py:class:`Schema` objects are built at import. :py:func:`hydrate` turns a tuple +into a cached :py:class:`Schema` on first use; the cache is keyed by the tuple's +identity (``id()``), which is stable because the tuples are module-level constants +that live for the process. Generated serialize/deserialize code calls +:py:func:`hydrate` once per shape per operation and reaches members positionally +via :py:meth:`Schema.member_at`. + +Encoding (mirrors smithy-typescript StaticSchema / StringStore / numeric traits): + +- Simple shape: ``(type_int, namespace, name, traits)`` +- Collection shape: ``(type_int, namespace, name, traits, member_names, member_targets)`` +- Operation/service: ``(type_int, namespace, name, traits)`` + +``member_targets`` is a tuple of ``(target, member_traits)`` pairs where ``target`` +is a prelude integer (see ``_PRELUDE``), a sibling shape's tuple, or a +``lambda: SIBLING`` thunk for a forward/recursive reference. + +``traits`` is an ``int`` bit-vector over the valueless two-state traits in +``_TRAIT_BITS`` (OR together for any combination), or a ``dict`` of interned trait +id -> value for valued/unknown traits (also carrying any valueless ones present). +""" + +from collections.abc import Callable +from typing import TYPE_CHECKING, Any, cast + +from . import prelude +from .schemas import Schema +from .shapes import ShapeID, ShapeType +from .traits import DynamicTrait, Trait + +if TYPE_CHECKING: + from .documents import DocumentValue + +# A compact schema is a positional tuple led by its ShapeType int. +type StaticSchema = tuple[Any, ...] +# A member target: a prelude int, a sibling tuple, or a lambda returning one. A built +# Schema is also accepted so an operation can be hand-initialized with real schemas. +type StaticSchemaRef = int | StaticSchema | Schema | Callable[[], "StaticSchemaRef"] +type StaticSchemaTraits = int | dict[str, "DocumentValue"] +# An operation's compact schema. The leading four slots are its own shape definition +# (type int, namespace, name, traits); the trailing three carry references to the +# input, output, and error schemas, so one value describes the whole operation. A ref +# may be a compact tuple, a built Schema, a prelude int, or a lambda returning one. +# Kept permissive (not a fixed-arity tuple) so a generated literal -- whose nested +# refs and valued-trait dicts have precise, partially-inferred element types -- still +# assigns under strict type checking. +type StaticOperationSchema = tuple[Any, ...] + +# Prelude integer substitutes. Index == the prelude shape's ShapeType value, so a +# bare simple-shape type int doubles as its prelude reference. +_PRELUDE: dict[int, Schema] = { + ShapeType.BLOB.value: prelude.BLOB, + ShapeType.BOOLEAN.value: prelude.BOOLEAN, + ShapeType.STRING.value: prelude.STRING, + ShapeType.TIMESTAMP.value: prelude.TIMESTAMP, + ShapeType.BYTE.value: prelude.BYTE, + ShapeType.SHORT.value: prelude.SHORT, + ShapeType.INTEGER.value: prelude.INTEGER, + ShapeType.LONG.value: prelude.LONG, + ShapeType.FLOAT.value: prelude.FLOAT, + ShapeType.DOUBLE.value: prelude.DOUBLE, + ShapeType.BIG_INTEGER.value: prelude.BIG_INTEGER, + ShapeType.BIG_DECIMAL.value: prelude.BIG_DECIMAL, + ShapeType.DOCUMENT.value: prelude.DOCUMENT, +} + +# The UNIT prelude schema, referenced by enum members. Given its own sentinel so it +# does not collide with a simple-type substitute. +UNIT = -1 +_PRELUDE[UNIT] = prelude.UNIT + +# Bit index -> trait id for valueless two-state traits. OR of bits encodes any +# combination; the width here allows well over 255 distinct combinations. +_TRAIT_BITS: tuple[str, ...] = ( + "smithy.api#required", + "smithy.api#idempotencyToken", + "smithy.api#sensitive", + "smithy.api#httpLabel", + "smithy.api#httpPayload", + "smithy.api#idempotent", + "smithy.api#sparse", + "smithy.api#httpResponseCode", + "smithy.api#hostLabel", + "smithy.api#requiresLength", + "smithy.api#httpQueryParams", + "smithy.api#notProperty", +) + +_TRAIT_BIT_IDS: tuple[ShapeID, ...] = tuple(ShapeID(t) for t in _TRAIT_BITS) + +_traits_cache: dict[int, dict[ShapeID, "Trait | DynamicTrait"]] = {} + + +def _expand_traits( + indicator: StaticSchemaTraits, +) -> dict[ShapeID, "Trait | DynamicTrait"]: + if isinstance(indicator, int): + cached = _traits_cache.get(indicator) + if cached is not None: + return cached + traits: dict[ShapeID, Trait | DynamicTrait] = {} + bit = indicator + i = 0 + while bit: + if bit & 1: + tid = _TRAIT_BIT_IDS[i] + traits[tid] = Trait.new(tid) + bit >>= 1 + i += 1 + _traits_cache[indicator] = traits + return traits + + out: dict[ShapeID, Trait | DynamicTrait] = {} + for raw_id, value in indicator.items(): + tid = ShapeID(raw_id) + out[tid] = Trait.new(tid, value) + return out + + +def _resolve(ref: "StaticSchemaRef") -> Schema: + """Resolve a member target or operation ref to a concrete Schema.""" + if isinstance(ref, Schema): + return ref + if isinstance(ref, int): + return _PRELUDE[ref] + if isinstance(ref, tuple): + return hydrate(cast(StaticSchema, ref)) + # a lambda: SIBLING forward/recursive reference + return _resolve(ref()) + + +# id(tuple) -> (tuple, hydrated Schema). The value keeps a reference to the keyed +# tuple so its id() can never be recycled onto a different tuple while cached -- which +# would otherwise let a transient hand-built tuple collide with a stale entry. +_cache: dict[int, tuple["StaticSchema", Schema]] = {} + +# ShapeType ints whose tuples carry a trailing (member_names, member_targets) pair. +# An operation's trailing slots are schema refs, not members, so it is excluded. +_MEMBER_SHAPE_TYPES: frozenset[int] = frozenset( + { + ShapeType.ENUM.value, + ShapeType.INT_ENUM.value, + ShapeType.LIST.value, + ShapeType.MAP.value, + ShapeType.STRUCTURE.value, + ShapeType.UNION.value, + } +) + + +def hydrate(data: "StaticSchema | Schema") -> Schema: + """Return the cached Schema for a compact schema tuple, building it on first use. + + A prelude shape's schema symbol is already a built :py:class:`Schema` (not a + tuple), so it passes through unchanged. + """ + if isinstance(data, Schema): + return data + + key = id(data) + cached = _cache.get(key) + if cached is not None: + return cached[1] + + type_int = cast(int, data[0]) + namespace = cast(str, data[1]) + shape_name = cast(str, data[2]) + traits = cast(StaticSchemaTraits, data[3]) + shape_type = ShapeType(type_int) + id_ = ShapeID.from_parts(namespace=namespace, name=shape_name) + + # Publish the empty container to the cache BEFORE resolving members, so a + # recursive member target that resolves back to this tuple sees the in-progress + # object instead of recursing forever. + schema = Schema(id=id_, shape_type=shape_type, traits=_expand_traits(traits)) + _cache[key] = (data, schema) + + if type_int in _MEMBER_SHAPE_TYPES and len(data) > 4: + member_names = cast(tuple[str, ...], data[4]) + member_targets = cast( + tuple[tuple[StaticSchemaRef, StaticSchemaTraits], ...], data[5] + ) + # Mutate the published members dict in place so a recursive target that + # captured it by reference during the cycle break observes the full map. + members = schema.members + for index, mname in enumerate(member_names): + target_ref, member_traits = member_targets[index] + target = _resolve(target_ref) + resolved = target.traits.copy() + resolved.update(_expand_traits(member_traits)) + members[mname] = Schema( + id=id_.with_member(mname), + shape_type=target.shape_type, + traits=resolved, + members=target.members, + member_target=target, + member_index=index, + ) + + return schema + + +# An operation tuple embeds its referenced schemas after its own schema definition: +# (type, ns, name, traits, input_ref, output_ref, error_refs). The op's own schema is +# built from slots 0-3 (operations have no members, so hydrate ignores the rest); the +# input, output, and error refs follow. Each ref is a shape tuple, a built Schema, a +# prelude int, or a lambda returning one. +_OP_INPUT = 4 +_OP_OUTPUT = 5 +_OP_ERRORS = 6 + + +def operation_input_schema(op: "StaticOperationSchema") -> Schema: + """Hydrate the input schema referenced by an operation tuple.""" + return _resolve(op[_OP_INPUT]) + + +def operation_output_schema(op: "StaticOperationSchema") -> Schema: + """Hydrate the output schema referenced by an operation tuple.""" + return _resolve(op[_OP_OUTPUT]) + + +def operation_error_schemas(op: "StaticOperationSchema") -> list[Schema]: + """Hydrate the error schemas referenced by an operation tuple.""" + return [_resolve(ref) for ref in op[_OP_ERRORS]] diff --git a/packages/smithy-core/src/smithy_core/schemas.py b/packages/smithy-core/src/smithy_core/schemas.py index 7da3486d4..452fac069 100644 --- a/packages/smithy-core/src/smithy_core/schemas.py +++ b/packages/smithy-core/src/smithy_core/schemas.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 from collections.abc import Callable, Mapping, Sequence from dataclasses import dataclass, field, replace +from functools import cached_property from itertools import count from typing import ( TYPE_CHECKING, @@ -24,6 +25,7 @@ ) if TYPE_CHECKING: + from ._schema_compact import StaticOperationSchema from .deserializers import DeserializeableShape from .documents import TypeRegistry from .serializers import SerializeableShape @@ -388,14 +390,13 @@ class APIOperation[I: "SerializeableShape", O: "DeserializeableShape"]: output: type[O] """The output type of the operation.""" - schema: Schema = field(repr=False) - """The schema of the operation.""" + static_schema: "StaticOperationSchema" = field(repr=False) + """The operation's compact schema tuple. - input_schema: Schema = field(repr=False) - """The schema of the operation's input shape.""" - - output_schema: Schema = field(repr=False) - """The schema of the operation's output shape.""" + An operation tuple carries its input, output, and error schema references in its + trailing slots, so this single symbol is the whole operation. The schema + properties hydrate from it and cache in place on first access. + """ error_registry: "TypeRegistry" """A TypeRegistry used to create errors.""" @@ -403,8 +404,33 @@ class APIOperation[I: "SerializeableShape", O: "DeserializeableShape"]: effective_auth_schemes: Sequence[ShapeID] """A list of effective auth schemes for the operation.""" - error_schemas: Sequence[Schema] = field(repr=False) - """A list of modeled error schemas for the operation.""" + @cached_property + def schema(self) -> Schema: + """The schema of the operation.""" + from ._schema_compact import hydrate + + return hydrate(self.static_schema) + + @cached_property + def input_schema(self) -> Schema: + """The schema of the operation's input shape.""" + from ._schema_compact import operation_input_schema + + return operation_input_schema(self.static_schema) + + @cached_property + def output_schema(self) -> Schema: + """The schema of the operation's output shape.""" + from ._schema_compact import operation_output_schema + + return operation_output_schema(self.static_schema) + + @cached_property + def error_schemas(self) -> Sequence[Schema]: + """The operation's modeled error schemas.""" + from ._schema_compact import operation_error_schemas + + return operation_error_schemas(self.static_schema) @property def idempotency_token_member(self) -> Schema | None: diff --git a/packages/smithy-core/tests/unit/aio/_pipeline_harness.py b/packages/smithy-core/tests/unit/aio/_pipeline_harness.py index 487898465..52cb2712a 100644 --- a/packages/smithy-core/tests/unit/aio/_pipeline_harness.py +++ b/packages/smithy-core/tests/unit/aio/_pipeline_harness.py @@ -73,15 +73,17 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: OPERATION = APIOperation( input=StubInput, output=StubOutput, - schema=Schema( - id=ShapeID("com.example#StreamingOperation"), - shape_type=ShapeType.OPERATION, + static_schema=( + ShapeType.OPERATION.value, + "com.example", + "StreamingOperation", + 0, + _INPUT_SCHEMA, + _OUTPUT_SCHEMA, + (), ), - input_schema=_INPUT_SCHEMA, - output_schema=_OUTPUT_SCHEMA, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[], ) # ``ClientCall.retryable()`` is False for operations with a streaming input, so @@ -90,15 +92,17 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self: UNARY_OPERATION = APIOperation( input=StubInput, output=StubOutput, - schema=Schema( - id=ShapeID("com.example#UnaryOperation"), - shape_type=ShapeType.OPERATION, + static_schema=( + ShapeType.OPERATION.value, + "com.example", + "UnaryOperation", + 0, + _UNARY_INPUT_SCHEMA, + _UNARY_OUTPUT_SCHEMA, + (), ), - input_schema=_UNARY_INPUT_SCHEMA, - output_schema=_UNARY_OUTPUT_SCHEMA, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[], ) diff --git a/packages/smithy-core/tests/unit/test_schemas.py b/packages/smithy-core/tests/unit/test_schemas.py index 963257199..0ec7f4151 100644 --- a/packages/smithy-core/tests/unit/test_schemas.py +++ b/packages/smithy-core/tests/unit/test_schemas.py @@ -282,13 +282,16 @@ def test_operation_idempotency_token_member(): operation = APIOperation[Any, Any]( input=object, output=object, - schema=Schema( - id=ShapeID("com.example#Operation"), shape_type=ShapeType.OPERATION + static_schema=( + ShapeType.OPERATION.value, + "com.example", + "Operation", + 0, + input_schema, + input_schema, + (), ), - input_schema=input_schema, - output_schema=input_schema, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[], ) assert operation.idempotency_token_member is input_schema.members["token"] diff --git a/packages/smithy-http/tests/unit/aio/test_protocols.py b/packages/smithy-http/tests/unit/aio/test_protocols.py index d27cab706..775bd22ff 100644 --- a/packages/smithy-http/tests/unit/aio/test_protocols.py +++ b/packages/smithy-http/tests/unit/aio/test_protocols.py @@ -14,7 +14,7 @@ from smithy_core.schemas import APIOperation, Schema from smithy_core.serializers import ShapeSerializer from smithy_core.shapes import ShapeID, ShapeType -from smithy_core.traits import HTTPPayloadTrait, HTTPTrait, StreamingTrait +from smithy_core.traits import HTTPPayloadTrait, StreamingTrait from smithy_core.types import TypedProperties from smithy_http import Field, Fields from smithy_http.aio import HTTPRequest, HTTPResponse @@ -173,16 +173,17 @@ def test_http_binding_protocol_falls_back_to_legacy_serialize() -> None: operation = APIOperation( input=LegacyInput, output=MockOutput, - schema=Schema( - id=ShapeID("ns.foo#LegacyOperation"), - shape_type=ShapeType.OPERATION, - traits=[HTTPTrait({"method": "POST", "code": 200, "uri": "/legacy"})], + static_schema=( + ShapeType.OPERATION.value, + "ns.foo", + "LegacyOperation", + {"smithy.api#http": {"method": "POST", "code": 200, "uri": "/legacy"}}, + LegacyInput.SCHEMA, + MockOutput.SCHEMA, + (), ), - input_schema=LegacyInput.SCHEMA, - output_schema=MockOutput.SCHEMA, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[], ) input = LegacyInput() @@ -202,16 +203,17 @@ def test_http_binding_protocol_uses_structure_fast_path() -> None: operation = APIOperation( input=StructInput, output=MockOutput, - schema=Schema( - id=ShapeID("ns.foo#StructOperation"), - shape_type=ShapeType.OPERATION, - traits=[HTTPTrait({"method": "POST", "code": 200, "uri": "/structure"})], + static_schema=( + ShapeType.OPERATION.value, + "ns.foo", + "StructOperation", + {"smithy.api#http": {"method": "POST", "code": 200, "uri": "/structure"}}, + StructInput.SCHEMA, + MockOutput.SCHEMA, + (), ), - input_schema=StructInput.SCHEMA, - output_schema=MockOutput.SCHEMA, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[], ) input = StructInput() @@ -247,16 +249,17 @@ def fail_if_scanned(_: APIOperation[Any, Any]) -> None: operation = APIOperation( input=LegacyInput, output=output, - schema=Schema( - id=ShapeID("ns.foo#DeserializeOperation"), - shape_type=ShapeType.OPERATION, - traits=[HTTPTrait({"method": "GET", "code": 200, "uri": "/"})], + static_schema=( + ShapeType.OPERATION.value, + "ns.foo", + "DeserializeOperation", + {"smithy.api#http": {"method": "GET", "code": 200, "uri": "/"}}, + LegacyInput.SCHEMA, + output.SCHEMA, + (), ), - input_schema=LegacyInput.SCHEMA, - output_schema=output.SCHEMA, error_registry=TypeRegistry({}), effective_auth_schemes=[], - error_schemas=[], ) request = HTTPRequest( destination=URI(host="example.com"), From f940d92152175ce8ad91d33f78849de080a9f833 Mon Sep 17 00:00:00 2001 From: George Fu Date: Fri, 9 Oct 2026 20:35:32 +0000 Subject: [PATCH 2/6] Add changelog and pare comments --- ...king-d1d7c841b70f4fc79c619917860d5a82.json | 4 ++++ .../src/smithy_core/_schema_compact.py | 19 +++++-------------- 2 files changed, 9 insertions(+), 14 deletions(-) create mode 100644 packages/smithy-core/.changes/next-release/smithy-core-breaking-d1d7c841b70f4fc79c619917860d5a82.json diff --git a/packages/smithy-core/.changes/next-release/smithy-core-breaking-d1d7c841b70f4fc79c619917860d5a82.json b/packages/smithy-core/.changes/next-release/smithy-core-breaking-d1d7c841b70f4fc79c619917860d5a82.json new file mode 100644 index 000000000..9f620efd7 --- /dev/null +++ b/packages/smithy-core/.changes/next-release/smithy-core-breaking-d1d7c841b70f4fc79c619917860d5a82.json @@ -0,0 +1,4 @@ +{ + "type": "breaking", + "description": "Changed generated schemas to a compact tuple encoding hydrated on first use, and reworked `APIOperation` to accept a single `static_schema` tuple with lazily-hydrated `schema`, `input_schema`, `output_schema`, and `error_schemas` properties." +} \ No newline at end of file diff --git a/packages/smithy-core/src/smithy_core/_schema_compact.py b/packages/smithy-core/src/smithy_core/_schema_compact.py index 2161b1792..51f3efce2 100644 --- a/packages/smithy-core/src/smithy_core/_schema_compact.py +++ b/packages/smithy-core/src/smithy_core/_schema_compact.py @@ -37,18 +37,13 @@ if TYPE_CHECKING: from .documents import DocumentValue -# A compact schema is a positional tuple led by its ShapeType int. type StaticSchema = tuple[Any, ...] # A member target: a prelude int, a sibling tuple, or a lambda returning one. A built # Schema is also accepted so an operation can be hand-initialized with real schemas. type StaticSchemaRef = int | StaticSchema | Schema | Callable[[], "StaticSchemaRef"] type StaticSchemaTraits = int | dict[str, "DocumentValue"] -# An operation's compact schema. The leading four slots are its own shape definition -# (type int, namespace, name, traits); the trailing three carry references to the -# input, output, and error schemas, so one value describes the whole operation. A ref -# may be a compact tuple, a built Schema, a prelude int, or a lambda returning one. -# Kept permissive (not a fixed-arity tuple) so a generated literal -- whose nested -# refs and valued-trait dicts have precise, partially-inferred element types -- still +# Permissive (not a fixed-arity tuple) so a generated operation literal -- whose +# nested refs and valued-trait dicts have partially-inferred element types -- still # assigns under strict type checking. type StaticOperationSchema = tuple[Any, ...] @@ -75,8 +70,8 @@ UNIT = -1 _PRELUDE[UNIT] = prelude.UNIT -# Bit index -> trait id for valueless two-state traits. OR of bits encodes any -# combination; the width here allows well over 255 distinct combinations. +# Bit index -> trait id for valueless two-state traits; OR of bits encodes any +# combination. _TRAIT_BITS: tuple[str, ...] = ( "smithy.api#required", "smithy.api#idempotencyToken", @@ -206,11 +201,7 @@ def hydrate(data: "StaticSchema | Schema") -> Schema: return schema -# An operation tuple embeds its referenced schemas after its own schema definition: -# (type, ns, name, traits, input_ref, output_ref, error_refs). The op's own schema is -# built from slots 0-3 (operations have no members, so hydrate ignores the rest); the -# input, output, and error refs follow. Each ref is a shape tuple, a built Schema, a -# prelude int, or a lambda returning one. +# Operation tuple slots after the shape definition (0-3): input, output, error refs. _OP_INPUT = 4 _OP_OUTPUT = 5 _OP_ERRORS = 6 From 2d3d1ab6b2f1c2b002e3fe3f3501eb4319311f09 Mon Sep 17 00:00:00 2001 From: George Fu Date: Fri, 9 Oct 2026 21:20:58 +0000 Subject: [PATCH 3/6] Suppress generated-schema pyright unknowns inline instead of project-wide Replace the four reportUnknown* settings in the generated pyproject with inline # pyright: ignore comments emitted only on the recursive/forward-ref schema lines that pyright cannot type (the lambda member targets and the assignment lines holding them). Keeps strict type checking everywhere else in the generated client. --- codegen-output/aws-json-1-0/pyproject.toml | 4 - codegen-output/aws-json-1-1/pyproject.toml | 4 - .../src/awsjson11/_private/schemas.py | 34 +++++-- codegen-output/aws-query/pyproject.toml | 4 - .../src/awsquery/_private/schemas.py | 32 ++++-- codegen-output/ec2-query/pyproject.toml | 4 - .../src/ec2query/_private/schemas.py | 32 ++++-- codegen-output/rest-json-1/pyproject.toml | 4 - .../src/restjson/_private/schemas.py | 15 +-- .../rest-xml-with-namespace/pyproject.toml | 4 - codegen-output/rest-xml/pyproject.toml | 4 - .../rest-xml/src/restxml/_private/schemas.py | 39 +++++--- codegen-output/rpcv2-cbor/pyproject.toml | 4 - .../src/rpcv2cbor/_private/schemas.py | 23 +++-- .../codegen/generators/SchemaGenerator.java | 99 +++++++++++++++---- .../codegen/generators/SetupGenerator.java | 4 - 16 files changed, 204 insertions(+), 106 deletions(-) diff --git a/codegen-output/aws-json-1-0/pyproject.toml b/codegen-output/aws-json-1-0/pyproject.toml index 0cde77bd1..de6d7aa27 100644 --- a/codegen-output/aws-json-1-0/pyproject.toml +++ b/codegen-output/aws-json-1-0/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/aws-json-1-1/pyproject.toml b/codegen-output/aws-json-1-1/pyproject.toml index 619fac867..a9b718abf 100644 --- a/codegen-output/aws-json-1-1/pyproject.toml +++ b/codegen-output/aws-json-1-1/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py b/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py index 7b5c1c7df..0ce412eff 100644 --- a/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py +++ b/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py @@ -603,7 +603,7 @@ (), ) -KITCHEN_SINK = ( +KITCHEN_SINK = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _KS, @@ -655,9 +655,9 @@ (MAP_OF_MAP_OF_STRINGS, 0), (MAP_OF_STRINGS, 0), (MAP_OF_STRUCTS, 0), - (lambda: LIST_OF_KITCHEN_SINKS, 0), - (lambda: MAP_OF_KITCHEN_SINKS, 0), - (lambda: KITCHEN_SINK, 0), + (lambda: LIST_OF_KITCHEN_SINKS, 0), # pyright: ignore[reportUnknownLambdaType] + (lambda: MAP_OF_KITCHEN_SINKS, 0), # pyright: ignore[reportUnknownLambdaType] + (lambda: KITCHEN_SINK, 0), # pyright: ignore[reportUnknownLambdaType] (SIMPLE_STRUCT, 0), (3, 0), (STRUCT_WITH_JSON_NAME, 0), @@ -666,11 +666,25 @@ ), ) -LIST_OF_KITCHEN_SINKS = (16, n0, _LOKS, 0, (_m,), ((KITCHEN_SINK, 0),)) +LIST_OF_KITCHEN_SINKS = ( # pyright: ignore[reportUnknownVariableType] + 16, + n0, + _LOKS, + 0, + (_m,), + ((KITCHEN_SINK, 0),), +) -MAP_OF_KITCHEN_SINKS = (17, n0, _MOKS, 0, (_k, _v), ((3, 0), (KITCHEN_SINK, 0))) +MAP_OF_KITCHEN_SINKS = ( # pyright: ignore[reportUnknownVariableType] + 17, + n0, + _MOKS, + 0, + (_k, _v), + ((3, 0), (KITCHEN_SINK, 0)), +) -ERROR_WITH_MEMBERS = ( +ERROR_WITH_MEMBERS = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _EWMr, @@ -687,7 +701,7 @@ ), ) -KITCHEN_SINK_OPERATION_INPUT = ( +KITCHEN_SINK_OPERATION_INPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _KSOI, @@ -750,7 +764,7 @@ ), ) -KITCHEN_SINK_OPERATION_OUTPUT = ( +KITCHEN_SINK_OPERATION_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _KSOO, @@ -813,7 +827,7 @@ ), ) -KITCHEN_SINK_OPERATION = ( +KITCHEN_SINK_OPERATION = ( # pyright: ignore[reportUnknownVariableType] 23, n0, _KSO, diff --git a/codegen-output/aws-query/pyproject.toml b/codegen-output/aws-query/pyproject.toml index 20a41fc0b..7fda39478 100644 --- a/codegen-output/aws-query/pyproject.toml +++ b/codegen-output/aws-query/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/aws-query/src/awsquery/_private/schemas.py b/codegen-output/aws-query/src/awsquery/_private/schemas.py index 8a2deb936..d8c2bdad5 100644 --- a/codegen-output/aws-query/src/awsquery/_private/schemas.py +++ b/codegen-output/aws-query/src/awsquery/_private/schemas.py @@ -997,27 +997,41 @@ XML_TIMESTAMPS = (23, n0, _XT, 0, XML_TIMESTAMPS_INPUT, XML_TIMESTAMPS_OUTPUT, ()) -STRUCT_ARG = ( +STRUCT_ARG = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _SA, 0, (_SAt, _OA, _RA), - ((3, 0), (2, 0), (lambda: STRUCT_ARG, 0)), + ( + (3, 0), + (2, 0), + (lambda: STRUCT_ARG, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -NESTED_STRUCTURES_INPUT = (18, n0, _NSI, 0, (_N,), ((STRUCT_ARG, 0),)) +NESTED_STRUCTURES_INPUT = ( # pyright: ignore[reportUnknownVariableType] + 18, + n0, + _NSI, + 0, + (_N,), + ((STRUCT_ARG, 0),), +) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( +RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _RXSON, 0, (_f, _n), - ((3, 0), (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0)), + ( + (3, 0), + (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( +RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _RXSONe, @@ -1026,7 +1040,7 @@ ((3, 0), (RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0)), ) -NESTED_STRUCTURES = ( +NESTED_STRUCTURES = ( # pyright: ignore[reportUnknownVariableType] 23, n0, _NS, @@ -1036,7 +1050,7 @@ (), ) -RECURSIVE_XML_SHAPES_OUTPUT = ( +RECURSIVE_XML_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _RXSO, @@ -1045,7 +1059,7 @@ ((RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0),), ) -RECURSIVE_XML_SHAPES = ( +RECURSIVE_XML_SHAPES = ( # pyright: ignore[reportUnknownVariableType] 23, n0, _RXS, diff --git a/codegen-output/ec2-query/pyproject.toml b/codegen-output/ec2-query/pyproject.toml index 322d56bf8..ed7ba732d 100644 --- a/codegen-output/ec2-query/pyproject.toml +++ b/codegen-output/ec2-query/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/ec2-query/src/ec2query/_private/schemas.py b/codegen-output/ec2-query/src/ec2query/_private/schemas.py index d7d45bfbe..fe4a78393 100644 --- a/codegen-output/ec2-query/src/ec2query/_private/schemas.py +++ b/codegen-output/ec2-query/src/ec2query/_private/schemas.py @@ -763,27 +763,41 @@ XML_TIMESTAMPS = (23, n0, _XT, 0, XML_TIMESTAMPS_INPUT, XML_TIMESTAMPS_OUTPUT, ()) -STRUCT_ARG = ( +STRUCT_ARG = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _SA, 0, (_SAt, _OA, _RA), - ((3, 0), (2, 0), (lambda: STRUCT_ARG, 0)), + ( + (3, 0), + (2, 0), + (lambda: STRUCT_ARG, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -NESTED_STRUCTURES_INPUT = (18, n0, _NSI, 0, (_N,), ((STRUCT_ARG, 0),)) +NESTED_STRUCTURES_INPUT = ( # pyright: ignore[reportUnknownVariableType] + 18, + n0, + _NSI, + 0, + (_N,), + ((STRUCT_ARG, 0),), +) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( +RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _RXSON, 0, (_f, _n), - ((3, 0), (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0)), + ( + (3, 0), + (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( +RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _RXSONe, @@ -792,7 +806,7 @@ ((3, 0), (RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0)), ) -NESTED_STRUCTURES = ( +NESTED_STRUCTURES = ( # pyright: ignore[reportUnknownVariableType] 23, n0, _NS, @@ -802,7 +816,7 @@ (), ) -RECURSIVE_XML_SHAPES_OUTPUT = ( +RECURSIVE_XML_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n0, _RXSO, @@ -811,7 +825,7 @@ ((RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0),), ) -RECURSIVE_XML_SHAPES = ( +RECURSIVE_XML_SHAPES = ( # pyright: ignore[reportUnknownVariableType] 23, n0, _RXS, diff --git a/codegen-output/rest-json-1/pyproject.toml b/codegen-output/rest-json-1/pyproject.toml index b852d3243..953379f29 100644 --- a/codegen-output/rest-json-1/pyproject.toml +++ b/codegen-output/rest-json-1/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rest-json-1/src/restjson/_private/schemas.py b/codegen-output/rest-json-1/src/restjson/_private/schemas.py index 07b9e8fe4..2fa47299d 100644 --- a/codegen-output/rest-json-1/src/restjson/_private/schemas.py +++ b/codegen-output/rest-json-1/src/restjson/_private/schemas.py @@ -3955,16 +3955,19 @@ (), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSION, 0, (_fo, _ne), - ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), + ( + (3, 0), + (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSIONe, @@ -3973,7 +3976,7 @@ ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), ) -RECURSIVE_SHAPES_INPUT = ( +RECURSIVE_SHAPES_INPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSI, @@ -3982,7 +3985,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES_OUTPUT = ( +RECURSIVE_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSO, @@ -3991,7 +3994,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES = ( +RECURSIVE_SHAPES = ( # pyright: ignore[reportUnknownVariableType] 23, n1, _RS, diff --git a/codegen-output/rest-xml-with-namespace/pyproject.toml b/codegen-output/rest-xml-with-namespace/pyproject.toml index a33d1c326..abe4a6800 100644 --- a/codegen-output/rest-xml-with-namespace/pyproject.toml +++ b/codegen-output/rest-xml-with-namespace/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rest-xml/pyproject.toml b/codegen-output/rest-xml/pyproject.toml index 603803fde..e59812bfa 100644 --- a/codegen-output/rest-xml/pyproject.toml +++ b/codegen-output/rest-xml/pyproject.toml @@ -52,10 +52,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rest-xml/src/restxml/_private/schemas.py b/codegen-output/rest-xml/src/restxml/_private/schemas.py index ac54da14f..afd0518ac 100644 --- a/codegen-output/rest-xml/src/restxml/_private/schemas.py +++ b/codegen-output/rest-xml/src/restxml/_private/schemas.py @@ -2689,7 +2689,7 @@ ((3, 0), (2, 0), (5, 0), (6, 0), (7, 0), (8, 0), (9, 0), (10, 0)), ) -XML_UNION_SHAPE = ( +XML_UNION_SHAPE = ( # pyright: ignore[reportUnknownVariableType] 19, n1, _XUS, @@ -2704,21 +2704,24 @@ (8, 0), (9, 0), (10, 0), - (lambda: XML_UNION_SHAPE, 0), + (lambda: XML_UNION_SHAPE, 0), # pyright: ignore[reportUnknownLambdaType] (XML_NESTED_UNION_STRUCT, 0), ), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSION, 0, (_f, _ne), - ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), + ( + (3, 0), + (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSIONe, @@ -2727,11 +2730,25 @@ ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), ) -XML_UNIONS_INPUT = (18, n1, _XUI, {_sSI: _aXUR}, (_uV,), ((XML_UNION_SHAPE, 0),)) +XML_UNIONS_INPUT = ( # pyright: ignore[reportUnknownVariableType] + 18, + n1, + _XUI, + {_sSI: _aXUR}, + (_uV,), + ((XML_UNION_SHAPE, 0),), +) -XML_UNIONS_OUTPUT = (18, n1, _XUO, {_sSI: _aXURw}, (_uV,), ((XML_UNION_SHAPE, 0),)) +XML_UNIONS_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] + 18, + n1, + _XUO, + {_sSI: _aXURw}, + (_uV,), + ((XML_UNION_SHAPE, 0),), +) -RECURSIVE_SHAPES_INPUT = ( +RECURSIVE_SHAPES_INPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSI, @@ -2740,7 +2757,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES_OUTPUT = ( +RECURSIVE_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSO, @@ -2749,7 +2766,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -XML_UNIONS = ( +XML_UNIONS = ( # pyright: ignore[reportUnknownVariableType] 23, n1, _XU, @@ -2759,7 +2776,7 @@ (), ) -RECURSIVE_SHAPES = ( +RECURSIVE_SHAPES = ( # pyright: ignore[reportUnknownVariableType] 23, n1, _RS, diff --git a/codegen-output/rpcv2-cbor/pyproject.toml b/codegen-output/rpcv2-cbor/pyproject.toml index 3d5db392f..5b6ca1746 100644 --- a/codegen-output/rpcv2-cbor/pyproject.toml +++ b/codegen-output/rpcv2-cbor/pyproject.toml @@ -53,10 +53,6 @@ reportUnusedFunction = false reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false -reportUnknownVariableType = false -reportUnknownMemberType = false -reportUnknownArgumentType = false -reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] diff --git a/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py b/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py index 0e55bb61c..bf2b9986a 100644 --- a/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py +++ b/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py @@ -731,16 +731,19 @@ (), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSION, 0, (_f, _n), - ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), + ( + (3, 0), + (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] + ), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSIONe, @@ -749,7 +752,7 @@ ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), ) -RECURSIVE_SHAPES_INPUT = ( +RECURSIVE_SHAPES_INPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSI, @@ -758,7 +761,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES_OUTPUT = ( +RECURSIVE_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] 18, n1, _RSO, @@ -767,7 +770,15 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES = (23, n1, _RS, 0, RECURSIVE_SHAPES_INPUT, RECURSIVE_SHAPES_OUTPUT, ()) +RECURSIVE_SHAPES = ( # pyright: ignore[reportUnknownVariableType] + 23, + n1, + _RS, + 0, + RECURSIVE_SHAPES_INPUT, + RECURSIVE_SHAPES_OUTPUT, + (), +) RPC_V2_PROTOCOL = ( 21, diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java index 8f23e0d7e..bf12dfcb4 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java @@ -100,6 +100,11 @@ public final class SchemaGenerator implements Consumer { // initialism and preferred-prefix allocation paths. private final Set allocated = new HashSet<>(); + // Shapes whose emitted tuple holds an unknown-typed value (a lambda, or a + // reference to another tainted shape). Their assignment lines get an inline + // reportUnknownVariableType ignore; nothing else does. + private final Set tainted = new HashSet<>(); + public SchemaGenerator(GenerationContext context) { this.context = context; } @@ -249,7 +254,17 @@ private void writeShape(PythonWriter writer, Shape shape) { int typeInt = typeInt(shape); var key = schemaName(shape); - writer.writeInline("$L = ($L, $L, $L, ", key, Integer.toString(typeInt), nsConst, nameConst); + boolean shapeTainted = computeTaint(shape); + if (shapeTainted) { + tainted.add(shape.getId()); + } + // The ignore rides the opening line as a trailing comment; the tuple continues + // across the following lines unaffected. + var opener = shapeTainted + ? "$L = ( # pyright: ignore[reportUnknownVariableType]" + : "$L = ("; + writer.write(opener, key); + writer.writeInline("$L, $L, $L, ", Integer.toString(typeInt), nsConst, nameConst); writeTraits(writer, traits); if (shape.isOperationShape()) { @@ -275,25 +290,55 @@ private void writeShape(PythonWriter writer, Shape shape) { written.add(shape.getId()); } + // A shape is unknown-tainted if any of its references is a lambda (forward or + // recursive) or points at an already-tainted shape; operations also consider their + // input, output, and error refs. Computed before emission so the opening line can + // carry the inline ignore. + private boolean computeTaint(Shape shape) { + if (shape.isOperationShape()) { + var op = shape.asOperationShape().get(); + var refs = new ArrayList(); + refs.add(op.getInputShape()); + refs.add(op.getOutputShape()); + refs.addAll(op.getErrors()); + return refs.stream().anyMatch(this::refTainted); + } + return shape.members().stream().anyMatch(m -> refTainted(m.getTarget())); + } + + private boolean refTainted(ShapeId target) { + return isLambdaTarget(target) || tainted.contains(target); + } + // Operation tuple trailing slots: input_ref, output_ref, (error_refs...). Matches // _schema_compact._OP_INPUT / _OP_OUTPUT / _OP_ERRORS. private void writeOperationRefs(PythonWriter writer, OperationShape op) { writer.write(","); - writer.writeInline(""); - writeSchemaRef(writer, op.getInputShape()); - writer.write(","); - writer.writeInline(""); - writeSchemaRef(writer, op.getOutputShape()); - writer.write(","); + writeOperationRef(writer, op.getInputShape()); + writeOperationRef(writer, op.getOutputShape()); writer.openBlock("(", ")", () -> { for (var error : op.getErrors()) { writer.writeInline(""); writeSchemaRef(writer, error); - writer.write(","); + writer.write(errorRefSuffix(error)); } }); } + private void writeOperationRef(PythonWriter writer, ShapeId target) { + writer.writeInline(""); + writeSchemaRef(writer, target); + writer.write(isLambdaTarget(target) + ? ", # pyright: ignore[reportUnknownLambdaType]" + : ","); + } + + private String errorRefSuffix(ShapeId target) { + return isLambdaTarget(target) + ? ", # pyright: ignore[reportUnknownLambdaType]" + : ","; + } + private String schemaName(Shape shape) { return context.symbolProvider() .toSymbol(shape) @@ -314,10 +359,24 @@ private void writeMemberTargets(PythonWriter writer, Shape shape) { for (var member : shape.members()) { writer.writeInline(""); writeMemberTarget(writer, member); - writer.write(","); + // Only an actual lambda line carries a lambda-return type pyright can't + // resolve; a tainted bare sibling is handled by the shape's opener ignore. + if (isLambdaTarget(member.getTarget())) { + writer.write(", # pyright: ignore[reportUnknownLambdaType]"); + } else { + writer.write(","); + } } } + // A member target emits a lambda when it is a non-prelude shape not yet defined in + // file order (a forward or recursive reference). + private boolean isLambdaTarget(ShapeId target) { + return !target.equals(UnitTypeTrait.UNIT) + && !PRELUDE_INTS.containsKey(target.toString()) + && !written.contains(target); + } + private void writeMemberTarget(PythonWriter writer, MemberShape member) { var memberTraits = filterTraits(member); writer.writeInline("("); @@ -327,21 +386,23 @@ private void writeMemberTarget(PythonWriter writer, MemberShape member) { writer.writeInline(")"); } - // Emits a reference to another shape's schema: a prelude int / UNIT sentinel for - // prelude targets, a bare sibling symbol when already defined above (folds as a - // constant), else a lambda for a forward or recursive reference. + // Emits a reference to another shape's schema: a prelude int / UNIT sentinel, a + // bare sibling symbol when already defined above (folds as a constant), else a + // lambda for a forward or recursive reference. private void writeSchemaRef(PythonWriter writer, ShapeId target) { if (target.equals(UnitTypeTrait.UNIT)) { writer.writeInline("$L", Integer.toString(UNIT_INT)); - } else if (PRELUDE_INTS.containsKey(target.toString())) { + return; + } + if (PRELUDE_INTS.containsKey(target.toString())) { writer.writeInline("$L", Integer.toString(PRELUDE_INTS.get(target.toString()))); + return; + } + var targetName = schemaName(context.model().expectShape(target)); + if (written.contains(target)) { + writer.writeInline("$L", targetName); } else { - var targetName = schemaName(context.model().expectShape(target)); - if (written.contains(target)) { - writer.writeInline("$L", targetName); - } else { - writer.writeInline("lambda: $L", targetName); - } + writer.writeInline("lambda: $L", targetName); } } diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java index 52d1f98cc..eda45fc54 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SetupGenerator.java @@ -171,10 +171,6 @@ private static void writePyproject( reportUnusedVariable = false reportUnnecessaryComparison = false reportUnusedClass = false - reportUnknownVariableType = false - reportUnknownMemberType = false - reportUnknownArgumentType = false - reportUnknownLambdaType = false enableExperimentalFeatures = true [tool.ruff] From 0c90d2dbbf08800bf6e8bf9942000f4413645045 Mon Sep 17 00:00:00 2001 From: George Fu Date: Tue, 13 Oct 2026 15:23:28 +0000 Subject: [PATCH 4/6] Write hydrated schema to cache only once fully populated Use a thread-local in-progress map to break reference cycles instead of publishing an empty schema to the shared cache, so a reader never sees a half-built schema and a failed hydration leaves nothing cached. Add schema hydration tests. --- .../src/smithy_core/_schema_compact.py | 75 +++++---- .../tests/unit/test_schema_compact.py | 155 ++++++++++++++++++ 2 files changed, 202 insertions(+), 28 deletions(-) create mode 100644 packages/smithy-core/tests/unit/test_schema_compact.py diff --git a/packages/smithy-core/src/smithy_core/_schema_compact.py b/packages/smithy-core/src/smithy_core/_schema_compact.py index 51f3efce2..9f04d1b0e 100644 --- a/packages/smithy-core/src/smithy_core/_schema_compact.py +++ b/packages/smithy-core/src/smithy_core/_schema_compact.py @@ -26,6 +26,7 @@ id -> value for valued/unknown traits (also carrying any valueless ones present). """ +import threading from collections.abc import Callable from typing import TYPE_CHECKING, Any, cast @@ -130,11 +131,20 @@ def _resolve(ref: "StaticSchemaRef") -> Schema: return _resolve(ref()) -# id(tuple) -> (tuple, hydrated Schema). The value keeps a reference to the keyed -# tuple so its id() can never be recycled onto a different tuple while cached -- which -# would otherwise let a transient hand-built tuple collide with a stale entry. +# id(tuple) -> fully hydrated Schema. A tuple is written here only once its members +# id(tuple) -> (tuple, fully hydrated Schema). A tuple is written here only once its +# members are fully resolved, so a reader never sees a half-built schema. The value +# keeps a reference to the keyed tuple so its id() can't be recycled onto a different +# tuple while cached -- which would otherwise let a transient hand-built tuple collide +# with a stale entry. _cache: dict[int, tuple["StaticSchema", Schema]] = {} +# Per-thread id(tuple) -> in-progress Schema, holding schemas mid-hydration so a +# recursive member target that resolves back to the same tuple gets the in-progress +# object instead of recursing forever. Thread-local so one thread never observes +# another's half-built schema. +_building = threading.local() + # ShapeType ints whose tuples carry a trailing (member_names, member_targets) pair. # An operation's trailing slots are schema refs, not members, so it is excluded. _MEMBER_SHAPE_TYPES: frozenset[int] = frozenset( @@ -163,6 +173,13 @@ def hydrate(data: "StaticSchema | Schema") -> Schema: if cached is not None: return cached[1] + stack: dict[int, Schema] | None = getattr(_building, "stack", None) + if stack is None: + stack = _building.stack = {} + building = stack.get(key) + if building is not None: + return building + type_int = cast(int, data[0]) namespace = cast(str, data[1]) shape_name = cast(str, data[2]) @@ -170,34 +187,36 @@ def hydrate(data: "StaticSchema | Schema") -> Schema: shape_type = ShapeType(type_int) id_ = ShapeID.from_parts(namespace=namespace, name=shape_name) - # Publish the empty container to the cache BEFORE resolving members, so a - # recursive member target that resolves back to this tuple sees the in-progress - # object instead of recursing forever. schema = Schema(id=id_, shape_type=shape_type, traits=_expand_traits(traits)) - _cache[key] = (data, schema) - - if type_int in _MEMBER_SHAPE_TYPES and len(data) > 4: - member_names = cast(tuple[str, ...], data[4]) - member_targets = cast( - tuple[tuple[StaticSchemaRef, StaticSchemaTraits], ...], data[5] - ) - # Mutate the published members dict in place so a recursive target that - # captured it by reference during the cycle break observes the full map. - members = schema.members - for index, mname in enumerate(member_names): - target_ref, member_traits = member_targets[index] - target = _resolve(target_ref) - resolved = target.traits.copy() - resolved.update(_expand_traits(member_traits)) - members[mname] = Schema( - id=id_.with_member(mname), - shape_type=target.shape_type, - traits=resolved, - members=target.members, - member_target=target, - member_index=index, + # Expose the in-progress schema for cycle breaking, but only to this thread and + # only until it is fully populated -- never in _cache until complete. + stack[key] = schema + try: + if type_int in _MEMBER_SHAPE_TYPES and len(data) > 4: + member_names = cast(tuple[str, ...], data[4]) + member_targets = cast( + tuple[tuple[StaticSchemaRef, StaticSchemaTraits], ...], data[5] ) + # Mutate the members dict in place so a recursive target that captured it + # by reference during the cycle break observes the full map. + members = schema.members + for index, mname in enumerate(member_names): + target_ref, member_traits = member_targets[index] + target = _resolve(target_ref) + resolved = target.traits.copy() + resolved.update(_expand_traits(member_traits)) + members[mname] = Schema( + id=id_.with_member(mname), + shape_type=target.shape_type, + traits=resolved, + members=target.members, + member_target=target, + member_index=index, + ) + finally: + del stack[key] + _cache[key] = (data, schema) return schema diff --git a/packages/smithy-core/tests/unit/test_schema_compact.py b/packages/smithy-core/tests/unit/test_schema_compact.py new file mode 100644 index 000000000..ed379a818 --- /dev/null +++ b/packages/smithy-core/tests/unit/test_schema_compact.py @@ -0,0 +1,155 @@ +# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 +# pyright: reportPrivateUsage=false, reportUnusedFunction=false +import threading +from collections.abc import Iterator + +import pytest +from smithy_core import _schema_compact +from smithy_core._schema_compact import StaticSchema, hydrate +from smithy_core.shapes import ShapeID, ShapeType +from smithy_core.traits import SensitiveTrait + +NS = "ns.example" + +# Trait-bit index for a known valueless two-state trait, used to exercise the +# shared-cache path in _expand_traits. +_SENSITIVE_BIT = 1 << _schema_compact._TRAIT_BITS.index(SensitiveTrait.id) + + +@pytest.fixture(autouse=True) +def _isolate_caches() -> Iterator[None]: + # The caches are module globals keyed by id(); isolate each test so a tuple + # built here can't collide with another test's recycled id(). + _schema_compact._cache.clear() + _schema_compact._traits_cache.clear() + yield + _schema_compact._cache.clear() + _schema_compact._traits_cache.clear() + + +def _struct(name: str, members: tuple[tuple[str, object], ...]) -> StaticSchema: + member_names = tuple(m[0] for m in members) + member_targets = tuple((m[1], 0) for m in members) + return (ShapeType.STRUCTURE.value, NS, name, 0, member_names, member_targets) + + +def test_simple_shape_hydrates_and_caches() -> None: + tup: StaticSchema = (ShapeType.STRING.value, NS, "Str", 0) + schema = hydrate(tup) + assert schema.id == ShapeID.from_parts(namespace=NS, name="Str") + assert schema.shape_type is ShapeType.STRING + assert hydrate(tup) is schema + + +def test_prelude_schema_passes_through() -> None: + from smithy_core import prelude + + assert hydrate(prelude.STRING) is prelude.STRING + + +def test_members_resolved_by_index() -> None: + tup = _struct("S", (("a", ShapeType.STRING.value), ("b", ShapeType.INTEGER.value))) + schema = hydrate(tup) + by_index = schema.members_by_index + assert by_index[0].expect_member_name() == "a" + assert by_index[1].expect_member_name() == "b" + + +def test_direct_recursion() -> None: + # A struct with a member targeting itself via a forward-ref thunk. + tup: StaticSchema = ( + ShapeType.STRUCTURE.value, + NS, + "Node", + 0, + ("next",), + ((lambda: tup, 0),), + ) + schema = hydrate(tup) + assert schema.members["next"].member_target is schema + + +def test_mutual_recursion() -> None: + a: StaticSchema = ( + ShapeType.STRUCTURE.value, + NS, + "A", + 0, + ("b",), + ((lambda: b, 0),), + ) + b: StaticSchema = ( + ShapeType.STRUCTURE.value, + NS, + "B", + 0, + ("a",), + ((lambda: a, 0),), + ) + schema_a = hydrate(a) + schema_b = hydrate(b) + assert schema_a.members["b"].member_target is schema_b + assert schema_b.members["a"].member_target is schema_a + + +def test_shared_trait_dict_not_corrupted_across_schemas() -> None: + # Two shapes carrying the same valueless trait bit share the cached trait dict; + # a member built from either must not mutate the other's traits. + first: StaticSchema = (ShapeType.STRING.value, NS, "First", _SENSITIVE_BIT) + second: StaticSchema = (ShapeType.STRING.value, NS, "Second", _SENSITIVE_BIT) + s1 = hydrate(first) + s2 = hydrate(second) + assert s1.get_trait(SensitiveTrait) is not None + assert s2.get_trait(SensitiveTrait) is not None + assert s1.traits == s2.traits + + +def test_failed_hydration_does_not_cache_partial_schema() -> None: + def boom() -> object: + raise ValueError("resolve failed") + + tup: StaticSchema = ( + ShapeType.STRUCTURE.value, + NS, + "Broken", + 0, + ("bad",), + ((boom, 0),), + ) + with pytest.raises(ValueError): + hydrate(tup) + # A retry must re-attempt, not return a half-populated schema from the cache. + with pytest.raises(ValueError): + hydrate(tup) + assert id(tup) not in _schema_compact._cache + + +def test_cache_pins_keyed_tuple_against_id_recycling() -> None: + # A transient (non-module-global) tuple must stay referenced by the cache, else + # its id() can be recycled onto a different tuple and return a stale schema. + tup: StaticSchema = (ShapeType.STRING.value, NS, "Transient", 0) + hydrate(tup) + assert _schema_compact._cache[id(tup)][0] is tup + + +def test_concurrent_hydration_returns_fully_populated_schema() -> None: + tup = _struct( + "Concurrent", + tuple((f"m{i}", ShapeType.STRING.value) for i in range(8)), + ) + results: list[object] = [] + barrier = threading.Barrier(16) + + def worker() -> None: + barrier.wait() + schema = hydrate(tup) + # Every thread must observe all members, never a cycle-break empty map. + results.append(len(schema.members)) + + threads = [threading.Thread(target=worker) for _ in range(16)] + for t in threads: + t.start() + for t in threads: + t.join() + assert results == [8] * 16 From 0fc899126154851488c0e85c5943fdbef3c3b498 Mon Sep 17 00:00:00 2001 From: George Fu Date: Tue, 13 Oct 2026 17:35:07 +0000 Subject: [PATCH 5/6] Annotate generated schemas so pyright infers no unknowns --- .../src/awsjson10/_private/schemas.py | 236 ++-- .../src/awsjson11/_private/schemas.py | 341 +++-- .../src/awsquery/_private/schemas.py | 512 +++++--- .../src/ec2query/_private/schemas.py | 401 ++++-- .../src/restjson/_private/schemas.py | 1167 ++++++++++------- .../restxmlwithnamespace/_private/schemas.py | 43 +- .../rest-xml/src/restxml/_private/schemas.py | 641 +++++---- .../src/rpcv2cbor/_private/schemas.py | 224 ++-- .../smithy/python/codegen/RuntimeTypes.java | 4 + .../codegen/generators/SchemaGenerator.java | 71 +- .../python/codegen/writer/PythonWriter.java | 5 +- 11 files changed, 2251 insertions(+), 1394 deletions(-) diff --git a/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py b/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py index d72b8c4e3..a64823a4a 100644 --- a/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py +++ b/codegen-output/aws-json-1-0/src/awsjson10/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.json10" _COD = "ClientOptionalDefaults" @@ -188,11 +190,11 @@ _sB = "smithy.rules#endpointBdd" _aw = "aws.api#service" -CLIENT_OPTIONAL_DEFAULTS = (18, n0, _COD, 0, (_m,), ((7, {_s: 0}),)) +CLIENT_OPTIONAL_DEFAULTS: StaticSchema = (18, n0, _COD, 0, (_m,), ((7, {_s: 0}),)) -COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, {_sN: _Fo}),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = (18, n0, _CNED, 0, (_F,), ((3, {_sN: _Fo}),)) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n0, _CE, @@ -201,11 +203,11 @@ ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -CONTENT_TYPE_PARAMETERS_INPUT = (18, n0, _CTPI, 0, (_v,), ((7, 0),)) +CONTENT_TYPE_PARAMETERS_INPUT: StaticSchema = (18, n0, _CTPI, 0, (_v,), ((7, 0),)) -CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n0, _CTPO, 0) +CONTENT_TYPE_PARAMETERS_OUTPUT: StaticSchema = (18, n0, _CTPO, 0) -CONTENT_TYPE_PARAMETERS = ( +CONTENT_TYPE_PARAMETERS: StaticOperationSchema = ( 23, n0, _CTP, @@ -215,15 +217,22 @@ (), ) -TEST_ENUM = (14, n0, _TE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) +TEST_ENUM: StaticSchema = ( + 14, + n0, + _TE, + 0, + (_FOO, _BAR, _BAZ), + ((-1, 0), (-1, 0), (-1, 0)), +) -TEST_INT_ENUM = (15, n0, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) +TEST_INT_ENUM: StaticSchema = (15, n0, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) -TEST_STRING_LIST = (16, n0, _TSL, 0, (_m,), ((3, 0),)) +TEST_STRING_LIST: StaticSchema = (16, n0, _TSL, 0, (_m,), ((3, 0),)) -TEST_STRING_MAP = (17, n0, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) +TEST_STRING_MAP: StaticSchema = (17, n0, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) -DEFAULTS = ( +DEFAULTS: StaticSchema = ( 18, n0, _D, @@ -290,19 +299,26 @@ ), ) -FAREWELL = (18, n0, _Fa, 0, (_p,), ((3, {_s: _b}),)) +FAREWELL: StaticSchema = (18, n0, _Fa, 0, (_p,), ((3, {_s: _b}),)) -DIALOG = (18, n0, _Di, 0, (_l, _g, _f), ((3, 0), (3, {_s: _h}), (FAREWELL, 0))) +DIALOG: StaticSchema = ( + 18, + n0, + _Di, + 0, + (_l, _g, _f), + ((3, 0), (3, {_s: _h}), (FAREWELL, 0)), +) -DIALOG_LIST = (16, n0, _DL, 0, (_m,), ((DIALOG, 0),)) +DIALOG_LIST: StaticSchema = (16, n0, _DL, 0, (_m,), ((DIALOG, 0),)) -DIALOG_MAP = (17, n0, _DM, 0, (_k, _v), ((3, 0), (DIALOG, 0))) +DIALOG_MAP: StaticSchema = (17, n0, _DM, 0, (_k, _v), ((3, 0), (DIALOG, 0))) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n0, _EIAEOI, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT: StaticSchema = (18, n0, _EIAEOI, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n0, _EIAEOO, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT: StaticSchema = (18, n0, _EIAEOO, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT = ( +EMPTY_INPUT_AND_EMPTY_OUTPUT: StaticOperationSchema = ( 23, n0, _EIAEO, @@ -312,11 +328,11 @@ (), ) -ENDPOINT_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) +ENDPOINT_OPERATION_INPUT: StaticSchema = (18, n0, _EOI, {_sSI: _sU}) -ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) +ENDPOINT_OPERATION_OUTPUT: StaticSchema = (18, n0, _EOO, {_sSI: _sU}) -ENDPOINT_OPERATION = ( +ENDPOINT_OPERATION: StaticOperationSchema = ( 23, n0, _EO, @@ -326,11 +342,18 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = (18, n0, _EWHLOI, 0, (_la,), ((3, 257),)) +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( + 18, + n0, + _EWHLOI, + 0, + (_la,), + ((3, 257),), +) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = (18, n0, _EWHLOO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( 23, n0, _EWHLO, @@ -340,15 +363,15 @@ (), ) -FOO_ERROR = (18, n0, _FE, {_sm: _se}) +FOO_ERROR: StaticSchema = (18, n0, _FE, {_sm: _se}) -GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, 0, (_g,), ((3, 0),)) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n0, _GWEI, 0, (_g,), ((3, 0),)) -GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -INVALID_GREETING = (18, n0, _IG, {_sm: _c}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n0, _IG, {_sm: _c}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n0, _GWE, @@ -358,11 +381,11 @@ (INVALID_GREETING, COMPLEX_ERROR, FOO_ERROR), ) -HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_INPUT: StaticSchema = (18, n0, _HWPOI, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_OUTPUT: StaticSchema = (18, n0, _HWPOO, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION = ( +HOST_WITH_PATH_OPERATION: StaticOperationSchema = ( 23, n0, _HWPO, @@ -372,7 +395,7 @@ (), ) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n1, _FEo, @@ -381,15 +404,15 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n1, _SL, 0, (_m,), ((3, 0),)) -STRING_MAP = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) +STRING_MAP: StaticSchema = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n1, _GS, 0, (_h,), ((3, 0),)) -MY_UNION = ( +MY_UNION: StaticSchema = ( 19, n0, _MU, @@ -409,17 +432,25 @@ ), ) -JSON_UNIONS_INPUT = (18, n0, _JUI, 0, (_co,), ((MY_UNION, 0),)) +JSON_UNIONS_INPUT: StaticSchema = (18, n0, _JUI, 0, (_co,), ((MY_UNION, 0),)) -JSON_UNIONS_OUTPUT = (18, n0, _JUO, 0, (_co,), ((MY_UNION, 0),)) +JSON_UNIONS_OUTPUT: StaticSchema = (18, n0, _JUO, 0, (_co,), ((MY_UNION, 0),)) -JSON_UNIONS = (23, n0, _JU, 0, JSON_UNIONS_INPUT, JSON_UNIONS_OUTPUT, ()) +JSON_UNIONS: StaticOperationSchema = ( + 23, + n0, + _JU, + 0, + JSON_UNIONS_INPUT, + JSON_UNIONS_OUTPUT, + (), +) -NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n0, _NIANOI, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_INPUT: StaticSchema = (18, n0, _NIANOI, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n0, _NIANOO, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_OUTPUT: StaticSchema = (18, n0, _NIANOO, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT = ( +NO_INPUT_AND_NO_OUTPUT: StaticOperationSchema = ( 23, n0, _NIANO, @@ -429,11 +460,11 @@ (), ) -NO_INPUT_AND_OUTPUT_INPUT = (18, n0, _NIAOI, {_sSI: _sU}) +NO_INPUT_AND_OUTPUT_INPUT: StaticSchema = (18, n0, _NIAOI, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_OUTPUT = (18, n0, _NIAOO, 0) +NO_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = (18, n0, _NIAOO, 0) -NO_INPUT_AND_OUTPUT = ( +NO_INPUT_AND_OUTPUT: StaticOperationSchema = ( 23, n0, _NIAO, @@ -443,7 +474,7 @@ (), ) -OPERATION_WITH_DEFAULTS_INPUT = ( +OPERATION_WITH_DEFAULTS_INPUT: StaticSchema = ( 18, n0, _OWDI, @@ -452,7 +483,7 @@ ((DEFAULTS, 0), (CLIENT_OPTIONAL_DEFAULTS, 0), (3, {_s: _h}), (7, {_s: 0})), ) -OPERATION_WITH_DEFAULTS_OUTPUT = ( +OPERATION_WITH_DEFAULTS_OUTPUT: StaticSchema = ( 18, n0, _OWDO, @@ -519,7 +550,7 @@ ), ) -OPERATION_WITH_DEFAULTS = ( +OPERATION_WITH_DEFAULTS: StaticOperationSchema = ( 23, n0, _OWD, @@ -529,7 +560,7 @@ (), ) -TOP_LEVEL = ( +TOP_LEVEL: StaticSchema = ( 18, n0, _TL, @@ -538,9 +569,16 @@ ((DIALOG, 1), (DIALOG_LIST, {_s: ()}), (DIALOG_MAP, {_s: None})), ) -OPERATION_WITH_NESTED_STRUCTURE_INPUT = (18, n0, _OWNSI, 0, (_tL,), ((TOP_LEVEL, 1),)) +OPERATION_WITH_NESTED_STRUCTURE_INPUT: StaticSchema = ( + 18, + n0, + _OWNSI, + 0, + (_tL,), + ((TOP_LEVEL, 1),), +) -OPERATION_WITH_NESTED_STRUCTURE_OUTPUT = ( +OPERATION_WITH_NESTED_STRUCTURE_OUTPUT: StaticSchema = ( 18, n0, _OWNSO, @@ -549,7 +587,7 @@ ((DIALOG, 1), (DIALOG_LIST, {_s: ()}), (DIALOG_MAP, {_s: None})), ) -OPERATION_WITH_NESTED_STRUCTURE = ( +OPERATION_WITH_NESTED_STRUCTURE: StaticOperationSchema = ( 23, n0, _OWNS, @@ -559,13 +597,13 @@ (), ) -OPERATION_WITH_REQUIRED_MEMBERS_INPUT = (18, n0, _OWRMI, {_sSI: _sU}) +OPERATION_WITH_REQUIRED_MEMBERS_INPUT: StaticSchema = (18, n0, _OWRMI, {_sSI: _sU}) -REQUIRED_STRING_LIST = (16, n0, _RSL, 0, (_m,), ((3, 0),)) +REQUIRED_STRING_LIST: StaticSchema = (16, n0, _RSL, 0, (_m,), ((3, 0),)) -REQUIRED_STRING_MAP = (17, n0, _RSM, 0, (_k, _v), ((3, 0), (3, 0))) +REQUIRED_STRING_MAP: StaticSchema = (17, n0, _RSM, 0, (_k, _v), ((3, 0), (3, 0))) -OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT = ( +OPERATION_WITH_REQUIRED_MEMBERS_OUTPUT: StaticSchema = ( 18, n0, _OWRMO, @@ -587,7 +625,7 @@ ), ) -OPERATION_WITH_REQUIRED_MEMBERS = ( +OPERATION_WITH_REQUIRED_MEMBERS: StaticOperationSchema = ( 23, n0, _OWRM, @@ -597,13 +635,25 @@ (), ) -OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT = (18, n0, _OWRMWDI, {_sSI: _sU}) +OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_INPUT: StaticSchema = ( + 18, + n0, + _OWRMWDI, + {_sSI: _sU}, +) -REQUIRED_ENUM = (14, n0, _RE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) +REQUIRED_ENUM: StaticSchema = ( + 14, + n0, + _RE, + 0, + (_FOO, _BAR, _BAZ), + ((-1, 0), (-1, 0), (-1, 0)), +) -REQUIRED_INT_ENUM = (15, n0, _RIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) +REQUIRED_INT_ENUM: StaticSchema = (15, n0, _RIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) -OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT = ( +OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS_OUTPUT: StaticSchema = ( 18, n0, _OWRMWDO, @@ -627,7 +677,7 @@ ), ) -OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS = ( +OPERATION_WITH_REQUIRED_MEMBERS_WITH_DEFAULTS: StaticOperationSchema = ( 23, n0, _OWRMWD, @@ -637,7 +687,7 @@ (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = ( +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( 18, n0, _PWCEI, @@ -646,9 +696,9 @@ ((3, {_sH: _CE_}), (3, 0)), ) -PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = (18, n0, _PWCEO, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING = ( +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( 23, n0, _PWCE, @@ -658,11 +708,11 @@ (), ) -QUERY_INCOMPATIBLE_OPERATION_INPUT = (18, n0, _QIOI, {_sSI: _sU}) +QUERY_INCOMPATIBLE_OPERATION_INPUT: StaticSchema = (18, n0, _QIOI, {_sSI: _sU}) -QUERY_INCOMPATIBLE_OPERATION_OUTPUT = (18, n0, _QIOO, {_sSI: _sU}) +QUERY_INCOMPATIBLE_OPERATION_OUTPUT: StaticSchema = (18, n0, _QIOO, {_sSI: _sU}) -QUERY_INCOMPATIBLE_OPERATION = ( +QUERY_INCOMPATIBLE_OPERATION: StaticOperationSchema = ( 23, n0, _QIO, @@ -672,11 +722,25 @@ (), ) -SIMPLE_SCALAR_PROPERTIES_INPUT = (18, n0, _SSPI, 0, (_fV, _dV), ((9, 0), (10, 0))) +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( + 18, + n0, + _SSPI, + 0, + (_fV, _dV), + ((9, 0), (10, 0)), +) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = (18, n0, _SSPO, 0, (_fV, _dV), ((9, 0), (10, 0))) +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( + 18, + n0, + _SSPO, + 0, + (_fV, _dV), + ((9, 0), (10, 0)), +) -SIMPLE_SCALAR_PROPERTIES = ( +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( 23, n0, _SSP, @@ -686,7 +750,7 @@ (), ) -JSON_RPC10 = ( +JSON_RPC10: StaticSchema = ( 21, n0, _JR, @@ -842,8 +906,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -855,8 +919,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonrpc10-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -875,8 +939,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonrpc10.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -888,8 +952,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonrpc10-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -908,8 +972,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonrpc10.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -928,8 +992,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonrpc10.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py b/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py index 0ce412eff..f803767ad 100644 --- a/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py +++ b/codegen-output/aws-json-1-1/src/awsjson11/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.json" _CNED = "ComplexNestedErrorData" @@ -204,9 +206,9 @@ _sB = "smithy.rules#endpointBdd" _aws = "aws.api#service" -COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, {_sN: _Fo}),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = (18, n0, _CNED, 0, (_F,), ((3, {_sN: _Fo}),)) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n0, _CE, @@ -215,11 +217,11 @@ ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -CONTENT_TYPE_PARAMETERS_INPUT = (18, n0, _CTPI, 0, (_v,), ((7, 0),)) +CONTENT_TYPE_PARAMETERS_INPUT: StaticSchema = (18, n0, _CTPI, 0, (_v,), ((7, 0),)) -CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n0, _CTPO, 0) +CONTENT_TYPE_PARAMETERS_OUTPUT: StaticSchema = (18, n0, _CTPO, 0) -CONTENT_TYPE_PARAMETERS = ( +CONTENT_TYPE_PARAMETERS: StaticOperationSchema = ( 23, n0, _CTP, @@ -229,29 +231,45 @@ (), ) -DATETIME_OFFSETS_INPUT = (18, n0, _DOI, {_sSI: _sU}) +DATETIME_OFFSETS_INPUT: StaticSchema = (18, n0, _DOI, {_sSI: _sU}) -DATE_TIME = (4, n1, _DT, {_sF: _dt}) +DATE_TIME: StaticSchema = (4, n1, _DT, {_sF: _dt}) -DATETIME_OFFSETS_OUTPUT = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) +DATETIME_OFFSETS_OUTPUT: StaticSchema = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -DATETIME_OFFSETS = (23, n0, _DO, 0, DATETIME_OFFSETS_INPUT, DATETIME_OFFSETS_OUTPUT, ()) +DATETIME_OFFSETS: StaticOperationSchema = ( + 23, + n0, + _DO, + 0, + DATETIME_OFFSETS_INPUT, + DATETIME_OFFSETS_OUTPUT, + (), +) -DOCUMENT = (13, n0, _D, 0) +DOCUMENT: StaticSchema = (13, n0, _D, 0) -EMPTY_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) +EMPTY_OPERATION_INPUT: StaticSchema = (18, n0, _EOI, {_sSI: _sU}) -EMPTY_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) +EMPTY_OPERATION_OUTPUT: StaticSchema = (18, n0, _EOO, {_sSI: _sU}) -EMPTY_OPERATION = (23, n0, _EO, 0, EMPTY_OPERATION_INPUT, EMPTY_OPERATION_OUTPUT, ()) +EMPTY_OPERATION: StaticOperationSchema = ( + 23, + n0, + _EO, + 0, + EMPTY_OPERATION_INPUT, + EMPTY_OPERATION_OUTPUT, + (), +) -EMPTY_STRUCT = (18, n0, _ES, 0) +EMPTY_STRUCT: StaticSchema = (18, n0, _ES, 0) -ENDPOINT_OPERATION_INPUT = (18, n0, _EOIn, {_sSI: _sU}) +ENDPOINT_OPERATION_INPUT: StaticSchema = (18, n0, _EOIn, {_sSI: _sU}) -ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOOn, {_sSI: _sU}) +ENDPOINT_OPERATION_OUTPUT: StaticSchema = (18, n0, _EOOn, {_sSI: _sU}) -ENDPOINT_OPERATION = ( +ENDPOINT_OPERATION: StaticOperationSchema = ( 23, n0, _EOn, @@ -261,7 +279,7 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( 18, n0, _EWHLOI, @@ -270,9 +288,9 @@ ((3, 257),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = (18, n0, _EWHLOO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( 23, n0, _EWHLO, @@ -282,37 +300,72 @@ (), ) -JSON_VALUE = (3, n0, _JV, {_sT: _a}) +JSON_VALUE: StaticSchema = (3, n0, _JV, {_sT: _a}) -LIST_OF_STRINGS = (16, n0, _LOS, 0, (_m,), ((3, 0),)) +LIST_OF_STRINGS: StaticSchema = (16, n0, _LOS, 0, (_m,), ((3, 0),)) -LIST_OF_LIST_OF_STRINGS = (16, n0, _LOLOS, 0, (_m,), ((LIST_OF_STRINGS, 0),)) +LIST_OF_LIST_OF_STRINGS: StaticSchema = ( + 16, + n0, + _LOLOS, + 0, + (_m,), + ((LIST_OF_STRINGS, 0),), +) -MAP_OF_STRINGS = (17, n0, _MOS, 0, (_k, _v), ((3, 0), (3, 0))) +MAP_OF_STRINGS: StaticSchema = (17, n0, _MOS, 0, (_k, _v), ((3, 0), (3, 0))) -LIST_OF_MAPS_OF_STRINGS = (16, n0, _LOMOS, 0, (_m,), ((MAP_OF_STRINGS, 0),)) +LIST_OF_MAPS_OF_STRINGS: StaticSchema = ( + 16, + n0, + _LOMOS, + 0, + (_m,), + ((MAP_OF_STRINGS, 0),), +) -SIMPLE_STRUCT = (18, n0, _SS, 0, (_V,), ((3, 0),)) +SIMPLE_STRUCT: StaticSchema = (18, n0, _SS, 0, (_V,), ((3, 0),)) -LIST_OF_STRUCTS = (16, n0, _LOSi, 0, (_m,), ((SIMPLE_STRUCT, 0),)) +LIST_OF_STRUCTS: StaticSchema = (16, n0, _LOSi, 0, (_m,), ((SIMPLE_STRUCT, 0),)) -MAP_OF_LISTS_OF_STRINGS = (17, n0, _MOLOS, 0, (_k, _v), ((3, 0), (LIST_OF_STRINGS, 0))) +MAP_OF_LISTS_OF_STRINGS: StaticSchema = ( + 17, + n0, + _MOLOS, + 0, + (_k, _v), + ((3, 0), (LIST_OF_STRINGS, 0)), +) -MAP_OF_MAP_OF_STRINGS = (17, n0, _MOMOS, 0, (_k, _v), ((3, 0), (MAP_OF_STRINGS, 0))) +MAP_OF_MAP_OF_STRINGS: StaticSchema = ( + 17, + n0, + _MOMOS, + 0, + (_k, _v), + ((3, 0), (MAP_OF_STRINGS, 0)), +) -MAP_OF_STRUCTS = (17, n0, _MOSa, 0, (_k, _v), ((3, 0), (SIMPLE_STRUCT, 0))) +MAP_OF_STRUCTS: StaticSchema = ( + 17, + n0, + _MOSa, + 0, + (_k, _v), + ((3, 0), (SIMPLE_STRUCT, 0)), +) -STRUCT_WITH_JSON_NAME = (18, n0, _SWJN, 0, (_V,), ((3, {_sN: _RM}),)) +STRUCT_WITH_JSON_NAME: StaticSchema = (18, n0, _SWJN, 0, (_V,), ((3, {_sN: _RM}),)) -ERROR_WITHOUT_MEMBERS = (18, n0, _EWM, {_s: _se}) +ERROR_WITHOUT_MEMBERS: StaticSchema = (18, n0, _EWM, {_s: _se}) -FOO_ERROR = (18, n0, _FE, {_s: _se}) +FOO_ERROR: StaticSchema = (18, n0, _FE, {_s: _se}) -FRACTIONAL_SECONDS_INPUT = (18, n0, _FSI, {_sSI: _sU}) +FRACTIONAL_SECONDS_INPUT: StaticSchema = (18, n0, _FSI, {_sSI: _sU}) -FRACTIONAL_SECONDS_OUTPUT = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -FRACTIONAL_SECONDS = ( +FRACTIONAL_SECONDS: StaticOperationSchema = ( 23, n0, _FS, @@ -322,13 +375,13 @@ (), ) -GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, {_sSI: _sU}) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n0, _GWEI, {_sSI: _sU}) -GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -INVALID_GREETING = (18, n0, _IG, {_s: _c}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n0, _IG, {_s: _c}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n0, _GWE, @@ -338,11 +391,11 @@ (INVALID_GREETING, COMPLEX_ERROR, FOO_ERROR), ) -HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_INPUT: StaticSchema = (18, n0, _HWPOI, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_OUTPUT: StaticSchema = (18, n0, _HWPOO, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION = ( +HOST_WITH_PATH_OPERATION: StaticOperationSchema = ( 23, n0, _HWPO, @@ -352,7 +405,7 @@ (), ) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n1, _FEo, @@ -361,13 +414,13 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -FOO_ENUM_LIST = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_LIST: StaticSchema = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -FOO_ENUM_MAP = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) +FOO_ENUM_MAP: StaticSchema = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -FOO_ENUM_SET = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_SET: StaticSchema = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -JSON_ENUMS_INPUT = ( +JSON_ENUMS_INPUT: StaticSchema = ( 18, n0, _JEI, @@ -383,7 +436,7 @@ ), ) -JSON_ENUMS_OUTPUT = ( +JSON_ENUMS_OUTPUT: StaticSchema = ( 18, n0, _JEO, @@ -399,17 +452,32 @@ ), ) -JSON_ENUMS = (23, n0, _JE, 0, JSON_ENUMS_INPUT, JSON_ENUMS_OUTPUT, ()) +JSON_ENUMS: StaticOperationSchema = ( + 23, + n0, + _JE, + 0, + JSON_ENUMS_INPUT, + JSON_ENUMS_OUTPUT, + (), +) -INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -INTEGER_ENUM_LIST = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_LIST: StaticSchema = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -INTEGER_ENUM_MAP = (17, n1, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) +INTEGER_ENUM_MAP: StaticSchema = ( + 17, + n1, + _IEM, + 0, + (_k, _v), + ((3, 0), (INTEGER_ENUM, 0)), +) -INTEGER_ENUM_SET = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_SET: StaticSchema = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) -JSON_INT_ENUMS_INPUT = ( +JSON_INT_ENUMS_INPUT: StaticSchema = ( 18, n0, _JIEI, @@ -425,7 +493,7 @@ ), ) -JSON_INT_ENUMS_OUTPUT = ( +JSON_INT_ENUMS_OUTPUT: StaticSchema = ( 18, n0, _JIEO, @@ -441,15 +509,23 @@ ), ) -JSON_INT_ENUMS = (23, n0, _JIE, 0, JSON_INT_ENUMS_INPUT, JSON_INT_ENUMS_OUTPUT, ()) +JSON_INT_ENUMS: StaticOperationSchema = ( + 23, + n0, + _JIE, + 0, + JSON_INT_ENUMS_INPUT, + JSON_INT_ENUMS_OUTPUT, + (), +) -STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n1, _SL, 0, (_m,), ((3, 0),)) -STRING_MAP = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) +STRING_MAP: StaticSchema = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n1, _GS, 0, (_h,), ((3, 0),)) -MY_UNION = ( +MY_UNION: StaticSchema = ( 19, n0, _MU, @@ -468,23 +544,67 @@ ), ) -JSON_UNIONS_INPUT = (18, n0, _JUI, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) +JSON_UNIONS_INPUT: StaticSchema = ( + 18, + n0, + _JUI, + {_sSI: _aUIO}, + (_co,), + ((MY_UNION, 0),), +) -JSON_UNIONS_OUTPUT = (18, n0, _JUO, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) +JSON_UNIONS_OUTPUT: StaticSchema = ( + 18, + n0, + _JUO, + {_sSI: _aUIO}, + (_co,), + ((MY_UNION, 0),), +) -JSON_UNIONS = (23, n0, _JU, 0, JSON_UNIONS_INPUT, JSON_UNIONS_OUTPUT, ()) +JSON_UNIONS: StaticOperationSchema = ( + 23, + n0, + _JU, + 0, + JSON_UNIONS_INPUT, + JSON_UNIONS_OUTPUT, + (), +) -NULL_OPERATION_INPUT = (18, n0, _NOI, {_sSI: _aNOIO}, (_st,), ((3, 0),)) +NULL_OPERATION_INPUT: StaticSchema = (18, n0, _NOI, {_sSI: _aNOIO}, (_st,), ((3, 0),)) -NULL_OPERATION_OUTPUT = (18, n0, _NOO, {_sSI: _aNOIO}, (_st,), ((3, 0),)) +NULL_OPERATION_OUTPUT: StaticSchema = (18, n0, _NOO, {_sSI: _aNOIO}, (_st,), ((3, 0),)) -NULL_OPERATION = (23, n0, _NO, 0, NULL_OPERATION_INPUT, NULL_OPERATION_OUTPUT, ()) +NULL_OPERATION: StaticOperationSchema = ( + 23, + n0, + _NO, + 0, + NULL_OPERATION_INPUT, + NULL_OPERATION_OUTPUT, + (), +) -OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT = (18, n0, _OWOIOI, 0, (_V,), ((3, 0),)) +OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_INPUT: StaticSchema = ( + 18, + n0, + _OWOIOI, + 0, + (_V,), + ((3, 0),), +) -OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT = (18, n0, _OWOIOO, 0, (_V,), ((3, 0),)) +OPERATION_WITH_OPTIONAL_INPUT_OUTPUT_OUTPUT: StaticSchema = ( + 18, + n0, + _OWOIOO, + 0, + (_V,), + ((3, 0),), +) -OPERATION_WITH_OPTIONAL_INPUT_OUTPUT = ( +OPERATION_WITH_OPTIONAL_INPUT_OUTPUT: StaticOperationSchema = ( 23, n0, _OWOIO, @@ -494,7 +614,7 @@ (), ) -PUT_AND_GET_INLINE_DOCUMENTS_INPUT = ( +PUT_AND_GET_INLINE_DOCUMENTS_INPUT: StaticSchema = ( 18, n0, _PAGIDI, @@ -503,7 +623,7 @@ ((DOCUMENT, 0),), ) -PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT = ( +PUT_AND_GET_INLINE_DOCUMENTS_OUTPUT: StaticSchema = ( 18, n0, _PAGIDO, @@ -512,7 +632,7 @@ ((DOCUMENT, 0),), ) -PUT_AND_GET_INLINE_DOCUMENTS = ( +PUT_AND_GET_INLINE_DOCUMENTS: StaticOperationSchema = ( 23, n0, _PAGID, @@ -522,7 +642,7 @@ (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = ( +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( 18, n0, _PWCEI, @@ -531,9 +651,9 @@ ((3, {_sH: _CE_}), (3, 0)), ) -PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = (18, n0, _PWCEO, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING = ( +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( 23, n0, _PWCE, @@ -543,7 +663,7 @@ (), ) -SIMPLE_SCALAR_PROPERTIES_INPUT = ( +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( 18, n0, _SSPI, @@ -552,7 +672,7 @@ ((9, 0), (10, 0)), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( 18, n0, _SSPO, @@ -561,7 +681,7 @@ ((9, 0), (10, 0)), ) -SIMPLE_SCALAR_PROPERTIES = ( +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( 23, n0, _SSP, @@ -571,11 +691,11 @@ (), ) -SPARSE_STRING_LIST = (16, n1, _SSL, 64, (_m,), ((3, 0),)) +SPARSE_STRING_LIST: StaticSchema = (16, n1, _SSL, 64, (_m,), ((3, 0),)) -SPARSE_STRING_MAP = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (3, 0))) +SPARSE_STRING_MAP: StaticSchema = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (3, 0))) -SPARSE_NULLS_OPERATION_INPUT = ( +SPARSE_NULLS_OPERATION_INPUT: StaticSchema = ( 18, n0, _SNOI, @@ -584,7 +704,7 @@ ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), ) -SPARSE_NULLS_OPERATION_OUTPUT = ( +SPARSE_NULLS_OPERATION_OUTPUT: StaticSchema = ( 18, n0, _SNOO, @@ -593,7 +713,7 @@ ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), ) -SPARSE_NULLS_OPERATION = ( +SPARSE_NULLS_OPERATION: StaticOperationSchema = ( 23, n0, _SNO, @@ -603,7 +723,7 @@ (), ) -KITCHEN_SINK = ( # pyright: ignore[reportUnknownVariableType] +KITCHEN_SINK: StaticSchema = ( 18, n0, _KS, @@ -655,9 +775,9 @@ (MAP_OF_MAP_OF_STRINGS, 0), (MAP_OF_STRINGS, 0), (MAP_OF_STRUCTS, 0), - (lambda: LIST_OF_KITCHEN_SINKS, 0), # pyright: ignore[reportUnknownLambdaType] - (lambda: MAP_OF_KITCHEN_SINKS, 0), # pyright: ignore[reportUnknownLambdaType] - (lambda: KITCHEN_SINK, 0), # pyright: ignore[reportUnknownLambdaType] + (lambda: LIST_OF_KITCHEN_SINKS, 0), + (lambda: MAP_OF_KITCHEN_SINKS, 0), + (lambda: KITCHEN_SINK, 0), (SIMPLE_STRUCT, 0), (3, 0), (STRUCT_WITH_JSON_NAME, 0), @@ -666,16 +786,9 @@ ), ) -LIST_OF_KITCHEN_SINKS = ( # pyright: ignore[reportUnknownVariableType] - 16, - n0, - _LOKS, - 0, - (_m,), - ((KITCHEN_SINK, 0),), -) +LIST_OF_KITCHEN_SINKS: StaticSchema = (16, n0, _LOKS, 0, (_m,), ((KITCHEN_SINK, 0),)) -MAP_OF_KITCHEN_SINKS = ( # pyright: ignore[reportUnknownVariableType] +MAP_OF_KITCHEN_SINKS: StaticSchema = ( 17, n0, _MOKS, @@ -684,7 +797,7 @@ ((3, 0), (KITCHEN_SINK, 0)), ) -ERROR_WITH_MEMBERS = ( # pyright: ignore[reportUnknownVariableType] +ERROR_WITH_MEMBERS: StaticSchema = ( 18, n0, _EWMr, @@ -701,7 +814,7 @@ ), ) -KITCHEN_SINK_OPERATION_INPUT = ( # pyright: ignore[reportUnknownVariableType] +KITCHEN_SINK_OPERATION_INPUT: StaticSchema = ( 18, n0, _KSOI, @@ -764,7 +877,7 @@ ), ) -KITCHEN_SINK_OPERATION_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +KITCHEN_SINK_OPERATION_OUTPUT: StaticSchema = ( 18, n0, _KSOO, @@ -827,7 +940,7 @@ ), ) -KITCHEN_SINK_OPERATION = ( # pyright: ignore[reportUnknownVariableType] +KITCHEN_SINK_OPERATION: StaticOperationSchema = ( 23, n0, _KSO, @@ -837,7 +950,7 @@ (ERROR_WITH_MEMBERS, ERROR_WITHOUT_MEMBERS), ) -JSON_PROTOCOL = ( +JSON_PROTOCOL: StaticSchema = ( 21, n0, _JP, @@ -993,8 +1106,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1006,8 +1119,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonprotocol-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1026,8 +1139,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonprotocol.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1039,8 +1152,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonprotocol-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1059,8 +1172,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonprotocol.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1079,8 +1192,8 @@ "endpoint": MappingProxyType( { "url": "https://jsonprotocol.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/aws-query/src/awsquery/_private/schemas.py b/codegen-output/aws-query/src/awsquery/_private/schemas.py index d8c2bdad5..0dbf2a879 100644 --- a/codegen-output/aws-query/src/awsquery/_private/schemas.py +++ b/codegen-output/aws-query/src/awsquery/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.query" _DOI = "DatetimeOffsetsInput" @@ -286,19 +288,27 @@ _sB = "smithy.rules#endpointBdd" _aws = "aws.api#service" -DATETIME_OFFSETS_INPUT = (18, n0, _DOI, {_sSI: _sU}) +DATETIME_OFFSETS_INPUT: StaticSchema = (18, n0, _DOI, {_sSI: _sU}) -DATE_TIME = (4, n1, _DT, {_sF: _dt}) +DATE_TIME: StaticSchema = (4, n1, _DT, {_sF: _dt}) -DATETIME_OFFSETS_OUTPUT = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) +DATETIME_OFFSETS_OUTPUT: StaticSchema = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -DATETIME_OFFSETS = (23, n0, _DO, 0, DATETIME_OFFSETS_INPUT, DATETIME_OFFSETS_OUTPUT, ()) +DATETIME_OFFSETS: StaticOperationSchema = ( + 23, + n0, + _DO, + 0, + DATETIME_OFFSETS_INPUT, + DATETIME_OFFSETS_OUTPUT, + (), +) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n0, _EIAEOI, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT: StaticSchema = (18, n0, _EIAEOI, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n0, _EIAEOO, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT: StaticSchema = (18, n0, _EIAEOO, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT = ( +EMPTY_INPUT_AND_EMPTY_OUTPUT: StaticOperationSchema = ( 23, n0, _EIAEO, @@ -308,11 +318,11 @@ (), ) -ENDPOINT_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) +ENDPOINT_OPERATION_INPUT: StaticSchema = (18, n0, _EOI, {_sSI: _sU}) -ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) +ENDPOINT_OPERATION_OUTPUT: StaticSchema = (18, n0, _EOO, {_sSI: _sU}) -ENDPOINT_OPERATION = ( +ENDPOINT_OPERATION: StaticOperationSchema = ( 23, n0, _EO, @@ -322,7 +332,7 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( 18, n0, _EWHLOI, @@ -331,9 +341,9 @@ ((3, 257),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = (18, n0, _EWHLOO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( 23, n0, _EWHLO, @@ -343,9 +353,9 @@ (), ) -FLATTENED_XML_MAP_INPUT = (18, n0, _FXMI, {_sSI: _sU}) +FLATTENED_XML_MAP_INPUT: StaticSchema = (18, n0, _FXMI, {_sSI: _sU}) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n1, _FE, @@ -354,11 +364,18 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -FOO_ENUM_MAP = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) +FOO_ENUM_MAP: StaticSchema = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -FLATTENED_XML_MAP_OUTPUT = (18, n0, _FXMO, 0, (_mM,), ((FOO_ENUM_MAP, {_sFm: None}),)) +FLATTENED_XML_MAP_OUTPUT: StaticSchema = ( + 18, + n0, + _FXMO, + 0, + (_mM,), + ((FOO_ENUM_MAP, {_sFm: None}),), +) -FLATTENED_XML_MAP = ( +FLATTENED_XML_MAP: StaticOperationSchema = ( 23, n0, _FXM, @@ -368,9 +385,9 @@ (), ) -FLATTENED_XML_MAP_WITH_XML_NAME_INPUT = (18, n0, _FXMWXNI, {_sSI: _sU}) +FLATTENED_XML_MAP_WITH_XML_NAME_INPUT: StaticSchema = (18, n0, _FXMWXNI, {_sSI: _sU}) -FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP = ( +FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP: StaticSchema = ( 17, n0, _FXMWXNOM, @@ -379,7 +396,7 @@ ((3, {_sN: _K}), (3, {_sN: _V})), ) -FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT = ( +FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT: StaticSchema = ( 18, n0, _FXMWXNO, @@ -388,7 +405,7 @@ ((FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT_MAP, {_sN: _KVP, _sFm: None}),), ) -FLATTENED_XML_MAP_WITH_XML_NAME = ( +FLATTENED_XML_MAP_WITH_XML_NAME: StaticOperationSchema = ( 23, n0, _FXMWXN, @@ -398,9 +415,14 @@ (), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT = (18, n0, _FXMWXNIl, {_sSI: _sU}) +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT: StaticSchema = ( + 18, + n0, + _FXMWXNIl, + {_sSI: _sU}, +) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP = ( +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP: StaticSchema = ( 17, n0, _FXMWXNOMl, @@ -415,7 +437,7 @@ ), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT = ( +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT: StaticSchema = ( 18, n0, _FXMWXNOl, @@ -433,7 +455,7 @@ ), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE = ( +FLATTENED_XML_MAP_WITH_XML_NAMESPACE: StaticOperationSchema = ( 23, n0, _FXMWXNl, @@ -443,11 +465,11 @@ (), ) -FRACTIONAL_SECONDS_INPUT = (18, n0, _FSI, {_sSI: _sU}) +FRACTIONAL_SECONDS_INPUT: StaticSchema = (18, n0, _FSI, {_sSI: _sU}) -FRACTIONAL_SECONDS_OUTPUT = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -FRACTIONAL_SECONDS = ( +FRACTIONAL_SECONDS: StaticOperationSchema = ( 23, n0, _FS, @@ -457,9 +479,9 @@ (), ) -COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, 0),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = (18, n0, _CNED, 0, (_F,), ((3, 0),)) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n0, _CE, @@ -468,7 +490,7 @@ ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -CUSTOM_CODE_ERROR = ( +CUSTOM_CODE_ERROR: StaticSchema = ( 18, n0, _CCE, @@ -477,13 +499,13 @@ ((3, 0),), ) -GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, {_sSI: _sU}) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n0, _GWEI, {_sSI: _sU}) -GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -INVALID_GREETING = (18, n0, _IG, {_smi: _c}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n0, _IG, {_smi: _c}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n0, _GWE, @@ -493,11 +515,11 @@ (INVALID_GREETING, COMPLEX_ERROR, CUSTOM_CODE_ERROR), ) -HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_INPUT: StaticSchema = (18, n0, _HWPOI, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_OUTPUT: StaticSchema = (18, n0, _HWPOO, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION = ( +HOST_WITH_PATH_OPERATION: StaticOperationSchema = ( 23, n0, _HWPO, @@ -507,11 +529,18 @@ (), ) -IGNORES_WRAPPING_XML_NAME_INPUT = (18, n0, _IWXNI, {_sSI: _sU}) +IGNORES_WRAPPING_XML_NAME_INPUT: StaticSchema = (18, n0, _IWXNI, {_sSI: _sU}) -IGNORES_WRAPPING_XML_NAME_OUTPUT = (18, n0, _IWXNO, {_sN: _IM}, (_f,), ((3, 0),)) +IGNORES_WRAPPING_XML_NAME_OUTPUT: StaticSchema = ( + 18, + n0, + _IWXNO, + {_sN: _IM}, + (_f,), + ((3, 0),), +) -IGNORES_WRAPPING_XML_NAME = ( +IGNORES_WRAPPING_XML_NAME: StaticOperationSchema = ( 23, n0, _IWXN, @@ -521,13 +550,13 @@ (), ) -NESTED_STRUCTURES_OUTPUT = (18, n0, _NSO, {_sSI: _sU}) +NESTED_STRUCTURES_OUTPUT: StaticSchema = (18, n0, _NSO, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n0, _NIANOI, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_INPUT: StaticSchema = (18, n0, _NIANOI, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n0, _NIANOO, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_OUTPUT: StaticSchema = (18, n0, _NIANOO, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT = ( +NO_INPUT_AND_NO_OUTPUT: StaticOperationSchema = ( 23, n0, _NIANO, @@ -537,11 +566,11 @@ (), ) -NO_INPUT_AND_OUTPUT_INPUT = (18, n0, _NIAOI, 0) +NO_INPUT_AND_OUTPUT_INPUT: StaticSchema = (18, n0, _NIAOI, 0) -NO_INPUT_AND_OUTPUT_OUTPUT = (18, n0, _NIAOO, 0) +NO_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = (18, n0, _NIAOO, 0) -NO_INPUT_AND_OUTPUT = ( +NO_INPUT_AND_OUTPUT: StaticOperationSchema = ( 23, n0, _NIAO, @@ -551,7 +580,7 @@ (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = ( +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( 18, n0, _PWCEI, @@ -560,9 +589,9 @@ ((3, {_sH: _CE_}), (3, 0)), ) -PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = (18, n0, _PWCEO, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING = ( +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( 23, n0, _PWCE, @@ -572,11 +601,18 @@ (), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = (18, n0, _QITAFI, 0, (_t,), ((3, 2),)) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT: StaticSchema = ( + 18, + n0, + _QITAFI, + 0, + (_t,), + ((3, 2),), +) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n0, _QITAFO, {_sSI: _sU}) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT: StaticSchema = (18, n0, _QITAFO, {_sSI: _sU}) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL: StaticOperationSchema = ( 23, n0, _QITAF, @@ -586,17 +622,17 @@ (), ) -GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n1, _GS, 0, (_h,), ((3, 0),)) -GREETING_LIST = (16, n1, _GL, 0, (_m,), ((GREETING_STRUCT, 0),)) +GREETING_LIST: StaticSchema = (16, n1, _GL, 0, (_m,), ((GREETING_STRUCT, 0),)) -STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n1, _SL, 0, (_m,), ((3, 0),)) -LIST_WITH_XML_NAME = (16, n0, _LWXN, 0, (_m,), ((3, {_sN: _i}),)) +LIST_WITH_XML_NAME: StaticSchema = (16, n0, _LWXN, 0, (_m,), ((3, {_sN: _i}),)) -NESTED_STRUCT_WITH_LIST = (18, n0, _NSWL, 0, (_LA,), ((STRING_LIST, 0),)) +NESTED_STRUCT_WITH_LIST: StaticSchema = (18, n0, _NSWL, 0, (_LA,), ((STRING_LIST, 0),)) -QUERY_LISTS_INPUT = ( +QUERY_LISTS_INPUT: StaticSchema = ( 18, n0, _QLI, @@ -612,21 +648,36 @@ ), ) -QUERY_LISTS_OUTPUT = (18, n0, _QLO, {_sSI: _sU}) +QUERY_LISTS_OUTPUT: StaticSchema = (18, n0, _QLO, {_sSI: _sU}) -QUERY_LISTS = (23, n0, _QL, 0, QUERY_LISTS_INPUT, QUERY_LISTS_OUTPUT, ()) +QUERY_LISTS: StaticOperationSchema = ( + 23, + n0, + _QL, + 0, + QUERY_LISTS_INPUT, + QUERY_LISTS_OUTPUT, + (), +) -COMPLEX_MAP = (17, n0, _CM, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) +COMPLEX_MAP: StaticSchema = (17, n0, _CM, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) -STRING_MAP = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) +STRING_MAP: StaticSchema = (17, n1, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -MAP_WITH_XML_NAME = (17, n0, _MWXN, 0, (_k, _v), ((3, {_sN: _K}), (3, {_sN: _V}))) +MAP_WITH_XML_NAME: StaticSchema = ( + 17, + n0, + _MWXN, + 0, + (_k, _v), + ((3, {_sN: _K}), (3, {_sN: _V})), +) -MAP_OF_LISTS = (17, n0, _MOL, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) +MAP_OF_LISTS: StaticSchema = (17, n0, _MOL, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) -NESTED_STRUCT_WITH_MAP = (18, n0, _NSWM, 0, (_MA,), ((STRING_MAP, 0),)) +NESTED_STRUCT_WITH_MAP: StaticSchema = (18, n0, _NSWM, 0, (_MA,), ((STRING_MAP, 0),)) -QUERY_MAPS_INPUT = ( +QUERY_MAPS_INPUT: StaticSchema = ( 18, n0, _QMI, @@ -644,13 +695,21 @@ ), ) -QUERY_MAPS_OUTPUT = (18, n0, _QMO, {_sSI: _sU}) +QUERY_MAPS_OUTPUT: StaticSchema = (18, n0, _QMO, {_sSI: _sU}) -QUERY_MAPS = (23, n0, _QM, 0, QUERY_MAPS_INPUT, QUERY_MAPS_OUTPUT, ()) +QUERY_MAPS: StaticOperationSchema = ( + 23, + n0, + _QM, + 0, + QUERY_MAPS_INPUT, + QUERY_MAPS_OUTPUT, + (), +) -EPOCH_SECONDS = (4, n1, _ES, {_sF: _es}) +EPOCH_SECONDS: StaticSchema = (4, n1, _ES, {_sF: _es}) -QUERY_TIMESTAMPS_INPUT = ( +QUERY_TIMESTAMPS_INPUT: StaticSchema = ( 18, n0, _QTI, @@ -659,15 +718,23 @@ ((4, 0), (4, {_sF: _es}), (EPOCH_SECONDS, 0)), ) -QUERY_TIMESTAMPS_OUTPUT = (18, n0, _QTO, {_sSI: _sU}) +QUERY_TIMESTAMPS_OUTPUT: StaticSchema = (18, n0, _QTO, {_sSI: _sU}) -QUERY_TIMESTAMPS = (23, n0, _QT, 0, QUERY_TIMESTAMPS_INPUT, QUERY_TIMESTAMPS_OUTPUT, ()) +QUERY_TIMESTAMPS: StaticOperationSchema = ( + 23, + n0, + _QT, + 0, + QUERY_TIMESTAMPS_INPUT, + QUERY_TIMESTAMPS_OUTPUT, + (), +) -RECURSIVE_XML_SHAPES_INPUT = (18, n0, _RXSI, {_sSI: _sU}) +RECURSIVE_XML_SHAPES_INPUT: StaticSchema = (18, n0, _RXSI, {_sSI: _sU}) -INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = (15, n1, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -SIMPLE_INPUT_PARAMS_INPUT = ( +SIMPLE_INPUT_PARAMS_INPUT: StaticSchema = ( 18, n0, _SIPI, @@ -686,9 +753,9 @@ ), ) -SIMPLE_INPUT_PARAMS_OUTPUT = (18, n0, _SIPO, {_sSI: _sU}) +SIMPLE_INPUT_PARAMS_OUTPUT: StaticSchema = (18, n0, _SIPO, {_sSI: _sU}) -SIMPLE_INPUT_PARAMS = ( +SIMPLE_INPUT_PARAMS: StaticOperationSchema = ( 23, n0, _SIP, @@ -698,9 +765,9 @@ (), ) -SIMPLE_SCALAR_XML_PROPERTIES_INPUT = (18, n0, _SSXPI, {_sSI: _sU}) +SIMPLE_SCALAR_XML_PROPERTIES_INPUT: StaticSchema = (18, n0, _SSXPI, {_sSI: _sU}) -SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT: StaticSchema = ( 18, n0, _SSXPO, @@ -720,7 +787,7 @@ ), ) -SIMPLE_SCALAR_XML_PROPERTIES = ( +SIMPLE_SCALAR_XML_PROPERTIES: StaticOperationSchema = ( 23, n0, _SSXP, @@ -730,27 +797,50 @@ (), ) -XML_BLOBS_INPUT = (18, n0, _XBI, {_sSI: _sU}) +XML_BLOBS_INPUT: StaticSchema = (18, n0, _XBI, {_sSI: _sU}) -XML_BLOBS_OPERATION_OUTPUT = (18, n0, _XBOO, {_sSI: _aXBO}, (_da,), ((1, 0),)) +XML_BLOBS_OPERATION_OUTPUT: StaticSchema = ( + 18, + n0, + _XBOO, + {_sSI: _aXBO}, + (_da,), + ((1, 0),), +) -XML_BLOBS = (23, n0, _XB, 0, XML_BLOBS_INPUT, XML_BLOBS_OPERATION_OUTPUT, ()) +XML_BLOBS: StaticOperationSchema = ( + 23, + n0, + _XB, + 0, + XML_BLOBS_INPUT, + XML_BLOBS_OPERATION_OUTPUT, + (), +) -XML_EMPTY_BLOBS_INPUT = (18, n0, _XEBI, {_sSI: _sU}) +XML_EMPTY_BLOBS_INPUT: StaticSchema = (18, n0, _XEBI, {_sSI: _sU}) -XML_EMPTY_BLOBS_OUTPUT = (18, n0, _XEBO, {_sSI: _aXBO}, (_da,), ((1, 0),)) +XML_EMPTY_BLOBS_OUTPUT: StaticSchema = (18, n0, _XEBO, {_sSI: _aXBO}, (_da,), ((1, 0),)) -XML_EMPTY_BLOBS = (23, n0, _XEB, 0, XML_EMPTY_BLOBS_INPUT, XML_EMPTY_BLOBS_OUTPUT, ()) +XML_EMPTY_BLOBS: StaticOperationSchema = ( + 23, + n0, + _XEB, + 0, + XML_EMPTY_BLOBS_INPUT, + XML_EMPTY_BLOBS_OUTPUT, + (), +) -XML_EMPTY_LISTS_INPUT = (18, n0, _XELI, {_sSI: _sU}) +XML_EMPTY_LISTS_INPUT: StaticSchema = (18, n0, _XELI, {_sSI: _sU}) -BOOLEAN_LIST = (16, n1, _BL, 0, (_m,), ((2, 0),)) +BOOLEAN_LIST: StaticSchema = (16, n1, _BL, 0, (_m,), ((2, 0),)) -FOO_ENUM_LIST = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_LIST: StaticSchema = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -RENAMED_LIST_MEMBERS = (16, n0, _RLM, 0, (_m,), ((3, {_sN: _i}),)) +RENAMED_LIST_MEMBERS: StaticSchema = (16, n0, _RLM, 0, (_m,), ((3, {_sN: _i}),)) -LIST_WITH_MEMBER_NAMESPACE = ( +LIST_WITH_MEMBER_NAMESPACE: StaticSchema = ( 16, n0, _LWMN, @@ -759,7 +849,7 @@ ((3, {_sNm: MappingProxyType({"uri": "https://xml-member.example.com"})}),), ) -LIST_WITH_NAMESPACE = ( +LIST_WITH_NAMESPACE: StaticSchema = ( 16, n0, _LWN, @@ -768,21 +858,35 @@ ((3, 0),), ) -INTEGER_LIST = (16, n1, _IL, 0, (_m,), ((7, 0),)) +INTEGER_LIST: StaticSchema = (16, n1, _IL, 0, (_m,), ((7, 0),)) -INTEGER_ENUM_LIST = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_LIST: StaticSchema = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -NESTED_STRING_LIST = (16, n1, _NSL, 0, (_m,), ((STRING_LIST, 0),)) +NESTED_STRING_LIST: StaticSchema = (16, n1, _NSL, 0, (_m,), ((STRING_LIST, 0),)) -STRING_SET = (16, n1, _SS, 0, (_m,), ((3, 0),)) +STRING_SET: StaticSchema = (16, n1, _SS, 0, (_m,), ((3, 0),)) -STRUCTURE_LIST_MEMBER = (18, n0, _SLM, 0, (_a, _b), ((3, {_sN: _v}), (3, {_sN: _o}))) +STRUCTURE_LIST_MEMBER: StaticSchema = ( + 18, + n0, + _SLM, + 0, + (_a, _b), + ((3, {_sN: _v}), (3, {_sN: _o})), +) -STRUCTURE_LIST = (16, n0, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, {_sN: _i}),)) +STRUCTURE_LIST: StaticSchema = ( + 16, + n0, + _SLt, + 0, + (_m,), + ((STRUCTURE_LIST_MEMBER, {_sN: _i}),), +) -TIMESTAMP_LIST = (16, n1, _TLi, 0, (_m,), ((4, 0),)) +TIMESTAMP_LIST: StaticSchema = (16, n1, _TLi, 0, (_m,), ((4, 0),)) -XML_EMPTY_LISTS_OUTPUT = ( +XML_EMPTY_LISTS_OUTPUT: StaticSchema = ( 18, n0, _XELO, @@ -806,13 +910,28 @@ ), ) -XML_EMPTY_LISTS = (23, n0, _XEL, 0, XML_EMPTY_LISTS_INPUT, XML_EMPTY_LISTS_OUTPUT, ()) +XML_EMPTY_LISTS: StaticOperationSchema = ( + 23, + n0, + _XEL, + 0, + XML_EMPTY_LISTS_INPUT, + XML_EMPTY_LISTS_OUTPUT, + (), +) -XML_EMPTY_MAPS_INPUT = (18, n0, _XEMI, {_sSI: _sU}) +XML_EMPTY_MAPS_INPUT: StaticSchema = (18, n0, _XEMI, {_sSI: _sU}) -XML_MAPS_OUTPUT_MAP = (17, n0, _XMOM, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) +XML_MAPS_OUTPUT_MAP: StaticSchema = ( + 17, + n0, + _XMOM, + 0, + (_k, _v), + ((3, 0), (GREETING_STRUCT, 0)), +) -XML_EMPTY_MAPS_OUTPUT = ( +XML_EMPTY_MAPS_OUTPUT: StaticSchema = ( 18, n0, _XEMO, @@ -821,13 +940,21 @@ ((XML_MAPS_OUTPUT_MAP, 0),), ) -XML_EMPTY_MAPS = (23, n0, _XEM, 0, XML_EMPTY_MAPS_INPUT, XML_EMPTY_MAPS_OUTPUT, ()) +XML_EMPTY_MAPS: StaticOperationSchema = ( + 23, + n0, + _XEM, + 0, + XML_EMPTY_MAPS_INPUT, + XML_EMPTY_MAPS_OUTPUT, + (), +) -XML_ENUMS_INPUT = (18, n0, _XEI, {_sSI: _sU}) +XML_ENUMS_INPUT: StaticSchema = (18, n0, _XEI, {_sSI: _sU}) -FOO_ENUM_SET = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_SET: StaticSchema = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -XML_ENUMS_OUTPUT = ( +XML_ENUMS_OUTPUT: StaticSchema = ( 18, n0, _XEO, @@ -843,15 +970,30 @@ ), ) -XML_ENUMS = (23, n0, _XE, 0, XML_ENUMS_INPUT, XML_ENUMS_OUTPUT, ()) +XML_ENUMS: StaticOperationSchema = ( + 23, + n0, + _XE, + 0, + XML_ENUMS_INPUT, + XML_ENUMS_OUTPUT, + (), +) -XML_INT_ENUMS_INPUT = (18, n0, _XIEI, {_sSI: _sU}) +XML_INT_ENUMS_INPUT: StaticSchema = (18, n0, _XIEI, {_sSI: _sU}) -INTEGER_ENUM_MAP = (17, n1, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) +INTEGER_ENUM_MAP: StaticSchema = ( + 17, + n1, + _IEM, + 0, + (_k, _v), + ((3, 0), (INTEGER_ENUM, 0)), +) -INTEGER_ENUM_SET = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_SET: StaticSchema = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) -XML_INT_ENUMS_OUTPUT = ( +XML_INT_ENUMS_OUTPUT: StaticSchema = ( 18, n0, _XIEO, @@ -867,11 +1009,19 @@ ), ) -XML_INT_ENUMS = (23, n0, _XIE, 0, XML_INT_ENUMS_INPUT, XML_INT_ENUMS_OUTPUT, ()) +XML_INT_ENUMS: StaticOperationSchema = ( + 23, + n0, + _XIE, + 0, + XML_INT_ENUMS_INPUT, + XML_INT_ENUMS_OUTPUT, + (), +) -XML_LISTS_INPUT = (18, n0, _XLI, {_sSI: _sU}) +XML_LISTS_INPUT: StaticSchema = (18, n0, _XLI, {_sSI: _sU}) -XML_LISTS_OPERATION_OUTPUT = ( +XML_LISTS_OPERATION_OUTPUT: StaticSchema = ( 18, n0, _XLOO, @@ -895,11 +1045,19 @@ ), ) -XML_LISTS = (23, n0, _XL, 0, XML_LISTS_INPUT, XML_LISTS_OPERATION_OUTPUT, ()) +XML_LISTS: StaticOperationSchema = ( + 23, + n0, + _XL, + 0, + XML_LISTS_INPUT, + XML_LISTS_OPERATION_OUTPUT, + (), +) -XML_MAPS_INPUT = (18, n0, _XMI, {_sSI: _sU}) +XML_MAPS_INPUT: StaticSchema = (18, n0, _XMI, {_sSI: _sU}) -XML_MAPS_OPERATION_OUTPUT = ( +XML_MAPS_OPERATION_OUTPUT: StaticSchema = ( 18, n0, _XMOO, @@ -908,11 +1066,19 @@ ((XML_MAPS_OUTPUT_MAP, 0),), ) -XML_MAPS = (23, n0, _XM, 0, XML_MAPS_INPUT, XML_MAPS_OPERATION_OUTPUT, ()) +XML_MAPS: StaticOperationSchema = ( + 23, + n0, + _XM, + 0, + XML_MAPS_INPUT, + XML_MAPS_OPERATION_OUTPUT, + (), +) -XML_MAPS_XML_NAME_INPUT = (18, n0, _XMXNI, {_sSI: _sU}) +XML_MAPS_XML_NAME_INPUT: StaticSchema = (18, n0, _XMXNI, {_sSI: _sU}) -XML_MAPS_XML_NAME_OUTPUT_MAP = ( +XML_MAPS_XML_NAME_OUTPUT_MAP: StaticSchema = ( 17, n0, _XMXNOM, @@ -921,7 +1087,7 @@ ((3, {_sN: _At}), (GREETING_STRUCT, {_sN: _S})), ) -XML_MAPS_XML_NAME_OUTPUT = ( +XML_MAPS_XML_NAME_OUTPUT: StaticSchema = ( 18, n0, _XMXNO, @@ -930,7 +1096,7 @@ ((XML_MAPS_XML_NAME_OUTPUT_MAP, 0),), ) -XML_MAPS_XML_NAME = ( +XML_MAPS_XML_NAME: StaticOperationSchema = ( 23, n0, _XMXN, @@ -940,9 +1106,9 @@ (), ) -XML_NAMESPACES_INPUT = (18, n0, _XNI, {_sSI: _sU}) +XML_NAMESPACES_INPUT: StaticSchema = (18, n0, _XNI, {_sSI: _sU}) -XML_NAMESPACED_LIST = ( +XML_NAMESPACED_LIST: StaticSchema = ( 16, n0, _XNL, @@ -951,7 +1117,7 @@ ((3, {_sNm: MappingProxyType({"uri": "http://bux.com"})}),), ) -XML_NAMESPACE_NESTED = ( +XML_NAMESPACE_NESTED: StaticSchema = ( 18, n0, _XNN, @@ -963,7 +1129,7 @@ ), ) -XML_NAMESPACES_OUTPUT = ( +XML_NAMESPACES_OUTPUT: StaticSchema = ( 18, n0, _XNO, @@ -972,13 +1138,21 @@ ((XML_NAMESPACE_NESTED, 0),), ) -XML_NAMESPACES = (23, n0, _XN, 0, XML_NAMESPACES_INPUT, XML_NAMESPACES_OUTPUT, ()) +XML_NAMESPACES: StaticOperationSchema = ( + 23, + n0, + _XN, + 0, + XML_NAMESPACES_INPUT, + XML_NAMESPACES_OUTPUT, + (), +) -XML_TIMESTAMPS_INPUT = (18, n0, _XTI, {_sSI: _sU}) +XML_TIMESTAMPS_INPUT: StaticSchema = (18, n0, _XTI, {_sSI: _sU}) -HTTP_DATE = (4, n1, _HD, {_sF: _hd}) +HTTP_DATE: StaticSchema = (4, n1, _HD, {_sF: _hd}) -XML_TIMESTAMPS_OUTPUT = ( +XML_TIMESTAMPS_OUTPUT: StaticSchema = ( 18, n0, _XTO, @@ -995,43 +1169,37 @@ ), ) -XML_TIMESTAMPS = (23, n0, _XT, 0, XML_TIMESTAMPS_INPUT, XML_TIMESTAMPS_OUTPUT, ()) - -STRUCT_ARG = ( # pyright: ignore[reportUnknownVariableType] - 18, +XML_TIMESTAMPS: StaticOperationSchema = ( + 23, n0, - _SA, + _XT, 0, - (_SAt, _OA, _RA), - ( - (3, 0), - (2, 0), - (lambda: STRUCT_ARG, 0), # pyright: ignore[reportUnknownLambdaType] - ), + XML_TIMESTAMPS_INPUT, + XML_TIMESTAMPS_OUTPUT, + (), ) -NESTED_STRUCTURES_INPUT = ( # pyright: ignore[reportUnknownVariableType] +STRUCT_ARG: StaticSchema = ( 18, n0, - _NSI, + _SA, 0, - (_N,), - ((STRUCT_ARG, 0),), + (_SAt, _OA, _RA), + ((3, 0), (2, 0), (lambda: STRUCT_ARG, 0)), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] +NESTED_STRUCTURES_INPUT: StaticSchema = (18, n0, _NSI, 0, (_N,), ((STRUCT_ARG, 0),)) + +RECURSIVE_XML_SHAPES_OUTPUT_NESTED1: StaticSchema = ( 18, n0, _RXSON, 0, (_f, _n), - ( - (3, 0), - (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] - ), + ((3, 0), (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0)), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_XML_SHAPES_OUTPUT_NESTED2: StaticSchema = ( 18, n0, _RXSONe, @@ -1040,7 +1208,7 @@ ((3, 0), (RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0)), ) -NESTED_STRUCTURES = ( # pyright: ignore[reportUnknownVariableType] +NESTED_STRUCTURES: StaticOperationSchema = ( 23, n0, _NS, @@ -1050,7 +1218,7 @@ (), ) -RECURSIVE_XML_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_XML_SHAPES_OUTPUT: StaticSchema = ( 18, n0, _RXSO, @@ -1059,7 +1227,7 @@ ((RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0),), ) -RECURSIVE_XML_SHAPES = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_XML_SHAPES: StaticOperationSchema = ( 23, n0, _RXS, @@ -1069,7 +1237,7 @@ (), ) -AWS_QUERY = ( +AWS_QUERY: StaticSchema = ( 21, n0, _AQ, @@ -1225,8 +1393,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1238,8 +1406,8 @@ "endpoint": MappingProxyType( { "url": "https://awsquery-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1258,8 +1426,8 @@ "endpoint": MappingProxyType( { "url": "https://awsquery.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1271,8 +1439,8 @@ "endpoint": MappingProxyType( { "url": "https://awsquery-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1291,8 +1459,8 @@ "endpoint": MappingProxyType( { "url": "https://awsquery.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1311,8 +1479,8 @@ "endpoint": MappingProxyType( { "url": "https://awsquery.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/ec2-query/src/ec2query/_private/schemas.py b/codegen-output/ec2-query/src/ec2query/_private/schemas.py index fe4a78393..f73d902dd 100644 --- a/codegen-output/ec2-query/src/ec2query/_private/schemas.py +++ b/codegen-output/ec2-query/src/ec2query/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.ec2" _DOI = "DatetimeOffsetsInput" @@ -250,19 +252,27 @@ _sB = "smithy.rules#endpointBdd" _aws = "aws.api#service" -DATETIME_OFFSETS_INPUT = (18, n0, _DOI, {_sSI: _sU}) +DATETIME_OFFSETS_INPUT: StaticSchema = (18, n0, _DOI, {_sSI: _sU}) -DATE_TIME = (4, n1, _DT, {_sF: _dt}) +DATE_TIME: StaticSchema = (4, n1, _DT, {_sF: _dt}) -DATETIME_OFFSETS_OUTPUT = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) +DATETIME_OFFSETS_OUTPUT: StaticSchema = (18, n0, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -DATETIME_OFFSETS = (23, n0, _DO, 0, DATETIME_OFFSETS_INPUT, DATETIME_OFFSETS_OUTPUT, ()) +DATETIME_OFFSETS: StaticOperationSchema = ( + 23, + n0, + _DO, + 0, + DATETIME_OFFSETS_INPUT, + DATETIME_OFFSETS_OUTPUT, + (), +) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n0, _EIAEOI, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT: StaticSchema = (18, n0, _EIAEOI, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n0, _EIAEOO, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT: StaticSchema = (18, n0, _EIAEOO, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT = ( +EMPTY_INPUT_AND_EMPTY_OUTPUT: StaticOperationSchema = ( 23, n0, _EIAEO, @@ -272,11 +282,11 @@ (), ) -ENDPOINT_OPERATION_INPUT = (18, n0, _EOI, {_sSI: _sU}) +ENDPOINT_OPERATION_INPUT: StaticSchema = (18, n0, _EOI, {_sSI: _sU}) -ENDPOINT_OPERATION_OUTPUT = (18, n0, _EOO, {_sSI: _sU}) +ENDPOINT_OPERATION_OUTPUT: StaticSchema = (18, n0, _EOO, {_sSI: _sU}) -ENDPOINT_OPERATION = ( +ENDPOINT_OPERATION: StaticOperationSchema = ( 23, n0, _EO, @@ -286,7 +296,7 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( 18, n0, _EWHLOI, @@ -295,9 +305,9 @@ ((3, 257),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n0, _EWHLOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = (18, n0, _EWHLOO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( 23, n0, _EWHLO, @@ -307,11 +317,11 @@ (), ) -FRACTIONAL_SECONDS_INPUT = (18, n0, _FSI, {_sSI: _sU}) +FRACTIONAL_SECONDS_INPUT: StaticSchema = (18, n0, _FSI, {_sSI: _sU}) -FRACTIONAL_SECONDS_OUTPUT = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = (18, n0, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -FRACTIONAL_SECONDS = ( +FRACTIONAL_SECONDS: StaticOperationSchema = ( 23, n0, _FS, @@ -321,9 +331,9 @@ (), ) -COMPLEX_NESTED_ERROR_DATA = (18, n0, _CNED, 0, (_F,), ((3, 0),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = (18, n0, _CNED, 0, (_F,), ((3, 0),)) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n0, _CE, @@ -332,13 +342,13 @@ ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -GREETING_WITH_ERRORS_INPUT = (18, n0, _GWEI, {_sSI: _sU}) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n0, _GWEI, {_sSI: _sU}) -GREETING_WITH_ERRORS_OUTPUT = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = (18, n0, _GWEO, 0, (_g,), ((3, 0),)) -INVALID_GREETING = (18, n0, _IG, {_smi: _c}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n0, _IG, {_smi: _c}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n0, _GWE, @@ -348,11 +358,11 @@ (INVALID_GREETING, COMPLEX_ERROR), ) -HOST_WITH_PATH_OPERATION_INPUT = (18, n0, _HWPOI, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_INPUT: StaticSchema = (18, n0, _HWPOI, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION_OUTPUT = (18, n0, _HWPOO, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_OUTPUT: StaticSchema = (18, n0, _HWPOO, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION = ( +HOST_WITH_PATH_OPERATION: StaticOperationSchema = ( 23, n0, _HWPO, @@ -362,11 +372,18 @@ (), ) -IGNORES_WRAPPING_XML_NAME_INPUT = (18, n0, _IWXNI, {_sSI: _sU}) +IGNORES_WRAPPING_XML_NAME_INPUT: StaticSchema = (18, n0, _IWXNI, {_sSI: _sU}) -IGNORES_WRAPPING_XML_NAME_OUTPUT = (18, n0, _IWXNO, {_sN: _IM}, (_f,), ((3, 0),)) +IGNORES_WRAPPING_XML_NAME_OUTPUT: StaticSchema = ( + 18, + n0, + _IWXNO, + {_sN: _IM}, + (_f,), + ((3, 0),), +) -IGNORES_WRAPPING_XML_NAME = ( +IGNORES_WRAPPING_XML_NAME: StaticOperationSchema = ( 23, n0, _IWXN, @@ -376,13 +393,13 @@ (), ) -NESTED_STRUCTURES_OUTPUT = (18, n0, _NSO, {_sSI: _sU}) +NESTED_STRUCTURES_OUTPUT: StaticSchema = (18, n0, _NSO, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_INPUT = (18, n0, _NIAOI, {_sSI: _sU}) +NO_INPUT_AND_OUTPUT_INPUT: StaticSchema = (18, n0, _NIAOI, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_OUTPUT = (18, n0, _NIAOO, 0) +NO_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = (18, n0, _NIAOO, 0) -NO_INPUT_AND_OUTPUT = ( +NO_INPUT_AND_OUTPUT: StaticOperationSchema = ( 23, n0, _NIAO, @@ -392,7 +409,7 @@ (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = ( +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( 18, n0, _PWCEI, @@ -401,9 +418,9 @@ ((3, {_sH: _CE_}), (3, 0)), ) -PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n0, _PWCEO, {_sSI: _sU}) +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = (18, n0, _PWCEO, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING = ( +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( 23, n0, _PWCE, @@ -413,11 +430,18 @@ (), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = (18, n0, _QITAFI, 0, (_t,), ((3, 2),)) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT: StaticSchema = ( + 18, + n0, + _QITAFI, + 0, + (_t,), + ((3, 2),), +) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n0, _QITAFO, {_sSI: _sU}) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT: StaticSchema = (18, n0, _QITAFO, {_sSI: _sU}) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL: StaticOperationSchema = ( 23, n0, _QITAF, @@ -427,17 +451,17 @@ (), ) -GREETING_STRUCT = (18, n1, _GS, 0, (_h,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n1, _GS, 0, (_h,), ((3, 0),)) -GREETING_LIST = (16, n1, _GL, 0, (_m,), ((GREETING_STRUCT, 0),)) +GREETING_LIST: StaticSchema = (16, n1, _GL, 0, (_m,), ((GREETING_STRUCT, 0),)) -STRING_LIST = (16, n1, _SL, 0, (_m,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n1, _SL, 0, (_m,), ((3, 0),)) -LIST_WITH_XML_NAME = (16, n0, _LWXN, 0, (_m,), ((3, {_sN: _i}),)) +LIST_WITH_XML_NAME: StaticSchema = (16, n0, _LWXN, 0, (_m,), ((3, {_sN: _i}),)) -NESTED_STRUCT_WITH_LIST = (18, n0, _NSWL, 0, (_LA,), ((STRING_LIST, 0),)) +NESTED_STRUCT_WITH_LIST: StaticSchema = (18, n0, _NSWL, 0, (_LA,), ((STRING_LIST, 0),)) -QUERY_LISTS_INPUT = ( +QUERY_LISTS_INPUT: StaticSchema = ( 18, n0, _QLI, @@ -452,13 +476,21 @@ ), ) -QUERY_LISTS_OUTPUT = (18, n0, _QLO, {_sSI: _sU}) +QUERY_LISTS_OUTPUT: StaticSchema = (18, n0, _QLO, {_sSI: _sU}) -QUERY_LISTS = (23, n0, _QL, 0, QUERY_LISTS_INPUT, QUERY_LISTS_OUTPUT, ()) +QUERY_LISTS: StaticOperationSchema = ( + 23, + n0, + _QL, + 0, + QUERY_LISTS_INPUT, + QUERY_LISTS_OUTPUT, + (), +) -EPOCH_SECONDS = (4, n1, _ES, {_sF: _es}) +EPOCH_SECONDS: StaticSchema = (4, n1, _ES, {_sF: _es}) -QUERY_TIMESTAMPS_INPUT = ( +QUERY_TIMESTAMPS_INPUT: StaticSchema = ( 18, n0, _QTI, @@ -467,13 +499,21 @@ ((4, 0), (4, {_sF: _es}), (EPOCH_SECONDS, 0)), ) -QUERY_TIMESTAMPS_OUTPUT = (18, n0, _QTO, {_sSI: _sU}) +QUERY_TIMESTAMPS_OUTPUT: StaticSchema = (18, n0, _QTO, {_sSI: _sU}) -QUERY_TIMESTAMPS = (23, n0, _QT, 0, QUERY_TIMESTAMPS_INPUT, QUERY_TIMESTAMPS_OUTPUT, ()) +QUERY_TIMESTAMPS: StaticOperationSchema = ( + 23, + n0, + _QT, + 0, + QUERY_TIMESTAMPS_INPUT, + QUERY_TIMESTAMPS_OUTPUT, + (), +) -RECURSIVE_XML_SHAPES_INPUT = (18, n0, _RXSI, {_sSI: _sU}) +RECURSIVE_XML_SHAPES_INPUT: StaticSchema = (18, n0, _RXSI, {_sSI: _sU}) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n1, _FE, @@ -482,7 +522,7 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -SIMPLE_INPUT_PARAMS_INPUT = ( +SIMPLE_INPUT_PARAMS_INPUT: StaticSchema = ( 18, n0, _SIPI, @@ -506,9 +546,9 @@ ), ) -SIMPLE_INPUT_PARAMS_OUTPUT = (18, n0, _SIPO, {_sSI: _sU}) +SIMPLE_INPUT_PARAMS_OUTPUT: StaticSchema = (18, n0, _SIPO, {_sSI: _sU}) -SIMPLE_INPUT_PARAMS = ( +SIMPLE_INPUT_PARAMS: StaticOperationSchema = ( 23, n0, _SIP, @@ -518,9 +558,9 @@ (), ) -SIMPLE_SCALAR_XML_PROPERTIES_INPUT = (18, n0, _SSXPI, {_sSI: _sU}) +SIMPLE_SCALAR_XML_PROPERTIES_INPUT: StaticSchema = (18, n0, _SSXPI, {_sSI: _sU}) -SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_XML_PROPERTIES_OUTPUT: StaticSchema = ( 18, n0, _SSXPO, @@ -540,7 +580,7 @@ ), ) -SIMPLE_SCALAR_XML_PROPERTIES = ( +SIMPLE_SCALAR_XML_PROPERTIES: StaticOperationSchema = ( 23, n0, _SSXP, @@ -550,27 +590,50 @@ (), ) -XML_BLOBS_INPUT = (18, n0, _XBI, {_sSI: _sU}) +XML_BLOBS_INPUT: StaticSchema = (18, n0, _XBI, {_sSI: _sU}) -XML_BLOBS_OPERATION_OUTPUT = (18, n0, _XBOO, {_sSI: _aXBO}, (_da,), ((1, 0),)) +XML_BLOBS_OPERATION_OUTPUT: StaticSchema = ( + 18, + n0, + _XBOO, + {_sSI: _aXBO}, + (_da,), + ((1, 0),), +) -XML_BLOBS = (23, n0, _XB, 0, XML_BLOBS_INPUT, XML_BLOBS_OPERATION_OUTPUT, ()) +XML_BLOBS: StaticOperationSchema = ( + 23, + n0, + _XB, + 0, + XML_BLOBS_INPUT, + XML_BLOBS_OPERATION_OUTPUT, + (), +) -XML_EMPTY_BLOBS_INPUT = (18, n0, _XEBI, {_sSI: _sU}) +XML_EMPTY_BLOBS_INPUT: StaticSchema = (18, n0, _XEBI, {_sSI: _sU}) -XML_EMPTY_BLOBS_OUTPUT = (18, n0, _XEBO, {_sSI: _aXBO}, (_da,), ((1, 0),)) +XML_EMPTY_BLOBS_OUTPUT: StaticSchema = (18, n0, _XEBO, {_sSI: _aXBO}, (_da,), ((1, 0),)) -XML_EMPTY_BLOBS = (23, n0, _XEB, 0, XML_EMPTY_BLOBS_INPUT, XML_EMPTY_BLOBS_OUTPUT, ()) +XML_EMPTY_BLOBS: StaticOperationSchema = ( + 23, + n0, + _XEB, + 0, + XML_EMPTY_BLOBS_INPUT, + XML_EMPTY_BLOBS_OUTPUT, + (), +) -XML_EMPTY_LISTS_INPUT = (18, n0, _XELI, {_sSI: _sU}) +XML_EMPTY_LISTS_INPUT: StaticSchema = (18, n0, _XELI, {_sSI: _sU}) -BOOLEAN_LIST = (16, n1, _BL, 0, (_m,), ((2, 0),)) +BOOLEAN_LIST: StaticSchema = (16, n1, _BL, 0, (_m,), ((2, 0),)) -FOO_ENUM_LIST = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_LIST: StaticSchema = (16, n1, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -RENAMED_LIST_MEMBERS = (16, n0, _RLM, 0, (_m,), ((3, {_sN: _i}),)) +RENAMED_LIST_MEMBERS: StaticSchema = (16, n0, _RLM, 0, (_m,), ((3, {_sN: _i}),)) -LIST_WITH_MEMBER_NAMESPACE = ( +LIST_WITH_MEMBER_NAMESPACE: StaticSchema = ( 16, n0, _LWMN, @@ -579,7 +642,7 @@ ((3, {_sNm: MappingProxyType({"uri": "https://xml-member.example.com"})}),), ) -LIST_WITH_NAMESPACE = ( +LIST_WITH_NAMESPACE: StaticSchema = ( 16, n0, _LWN, @@ -588,23 +651,44 @@ ((3, 0),), ) -INTEGER_LIST = (16, n1, _IL, 0, (_m,), ((7, 0),)) +INTEGER_LIST: StaticSchema = (16, n1, _IL, 0, (_m,), ((7, 0),)) -INTEGER_ENUM = (15, n1, _IE, 0, (_A, _B_, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = ( + 15, + n1, + _IE, + 0, + (_A, _B_, _C), + ((-1, 0), (-1, 0), (-1, 0)), +) -INTEGER_ENUM_LIST = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_LIST: StaticSchema = (16, n1, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -NESTED_STRING_LIST = (16, n1, _NSL, 0, (_m,), ((STRING_LIST, 0),)) +NESTED_STRING_LIST: StaticSchema = (16, n1, _NSL, 0, (_m,), ((STRING_LIST, 0),)) -STRING_SET = (16, n1, _SS, 0, (_m,), ((3, 0),)) +STRING_SET: StaticSchema = (16, n1, _SS, 0, (_m,), ((3, 0),)) -STRUCTURE_LIST_MEMBER = (18, n0, _SLM, 0, (_a, _b), ((3, {_sN: _v}), (3, {_sN: _o}))) +STRUCTURE_LIST_MEMBER: StaticSchema = ( + 18, + n0, + _SLM, + 0, + (_a, _b), + ((3, {_sN: _v}), (3, {_sN: _o})), +) -STRUCTURE_LIST = (16, n0, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, {_sN: _i}),)) +STRUCTURE_LIST: StaticSchema = ( + 16, + n0, + _SLt, + 0, + (_m,), + ((STRUCTURE_LIST_MEMBER, {_sN: _i}),), +) -TIMESTAMP_LIST = (16, n1, _TLi, 0, (_m,), ((4, 0),)) +TIMESTAMP_LIST: StaticSchema = (16, n1, _TLi, 0, (_m,), ((4, 0),)) -XML_EMPTY_LISTS_OUTPUT = ( +XML_EMPTY_LISTS_OUTPUT: StaticSchema = ( 18, n0, _XELO, @@ -628,15 +712,23 @@ ), ) -XML_EMPTY_LISTS = (23, n0, _XEL, 0, XML_EMPTY_LISTS_INPUT, XML_EMPTY_LISTS_OUTPUT, ()) +XML_EMPTY_LISTS: StaticOperationSchema = ( + 23, + n0, + _XEL, + 0, + XML_EMPTY_LISTS_INPUT, + XML_EMPTY_LISTS_OUTPUT, + (), +) -XML_ENUMS_INPUT = (18, n0, _XEI, {_sSI: _sU}) +XML_ENUMS_INPUT: StaticSchema = (18, n0, _XEI, {_sSI: _sU}) -FOO_ENUM_MAP = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) +FOO_ENUM_MAP: StaticSchema = (17, n1, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -FOO_ENUM_SET = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_SET: StaticSchema = (16, n1, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -XML_ENUMS_OUTPUT = ( +XML_ENUMS_OUTPUT: StaticSchema = ( 18, n0, _XEO, @@ -652,15 +744,30 @@ ), ) -XML_ENUMS = (23, n0, _XE, 0, XML_ENUMS_INPUT, XML_ENUMS_OUTPUT, ()) +XML_ENUMS: StaticOperationSchema = ( + 23, + n0, + _XE, + 0, + XML_ENUMS_INPUT, + XML_ENUMS_OUTPUT, + (), +) -XML_INT_ENUMS_INPUT = (18, n0, _XIEI, {_sSI: _sU}) +XML_INT_ENUMS_INPUT: StaticSchema = (18, n0, _XIEI, {_sSI: _sU}) -INTEGER_ENUM_MAP = (17, n1, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) +INTEGER_ENUM_MAP: StaticSchema = ( + 17, + n1, + _IEM, + 0, + (_k, _v), + ((3, 0), (INTEGER_ENUM, 0)), +) -INTEGER_ENUM_SET = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_SET: StaticSchema = (16, n1, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) -XML_INT_ENUMS_OUTPUT = ( +XML_INT_ENUMS_OUTPUT: StaticSchema = ( 18, n0, _XIEO, @@ -676,11 +783,19 @@ ), ) -XML_INT_ENUMS = (23, n0, _XIE, 0, XML_INT_ENUMS_INPUT, XML_INT_ENUMS_OUTPUT, ()) +XML_INT_ENUMS: StaticOperationSchema = ( + 23, + n0, + _XIE, + 0, + XML_INT_ENUMS_INPUT, + XML_INT_ENUMS_OUTPUT, + (), +) -XML_LISTS_INPUT = (18, n0, _XLI, {_sSI: _sU}) +XML_LISTS_INPUT: StaticSchema = (18, n0, _XLI, {_sSI: _sU}) -XML_LISTS_OPERATION_OUTPUT = ( +XML_LISTS_OPERATION_OUTPUT: StaticSchema = ( 18, n0, _XLOO, @@ -704,11 +819,19 @@ ), ) -XML_LISTS = (23, n0, _XL, 0, XML_LISTS_INPUT, XML_LISTS_OPERATION_OUTPUT, ()) +XML_LISTS: StaticOperationSchema = ( + 23, + n0, + _XL, + 0, + XML_LISTS_INPUT, + XML_LISTS_OPERATION_OUTPUT, + (), +) -XML_NAMESPACES_INPUT = (18, n0, _XNI, {_sSI: _sU}) +XML_NAMESPACES_INPUT: StaticSchema = (18, n0, _XNI, {_sSI: _sU}) -XML_NAMESPACED_LIST = ( +XML_NAMESPACED_LIST: StaticSchema = ( 16, n0, _XNL, @@ -717,7 +840,7 @@ ((3, {_sNm: MappingProxyType({"uri": "http://bux.com"})}),), ) -XML_NAMESPACE_NESTED = ( +XML_NAMESPACE_NESTED: StaticSchema = ( 18, n0, _XNN, @@ -729,7 +852,7 @@ ), ) -XML_NAMESPACES_OUTPUT = ( +XML_NAMESPACES_OUTPUT: StaticSchema = ( 18, n0, _XNO, @@ -738,13 +861,21 @@ ((XML_NAMESPACE_NESTED, 0),), ) -XML_NAMESPACES = (23, n0, _XN, 0, XML_NAMESPACES_INPUT, XML_NAMESPACES_OUTPUT, ()) +XML_NAMESPACES: StaticOperationSchema = ( + 23, + n0, + _XN, + 0, + XML_NAMESPACES_INPUT, + XML_NAMESPACES_OUTPUT, + (), +) -XML_TIMESTAMPS_INPUT = (18, n0, _XTI, {_sSI: _sU}) +XML_TIMESTAMPS_INPUT: StaticSchema = (18, n0, _XTI, {_sSI: _sU}) -HTTP_DATE = (4, n1, _HD, {_sF: _hd}) +HTTP_DATE: StaticSchema = (4, n1, _HD, {_sF: _hd}) -XML_TIMESTAMPS_OUTPUT = ( +XML_TIMESTAMPS_OUTPUT: StaticSchema = ( 18, n0, _XTO, @@ -761,43 +892,37 @@ ), ) -XML_TIMESTAMPS = (23, n0, _XT, 0, XML_TIMESTAMPS_INPUT, XML_TIMESTAMPS_OUTPUT, ()) - -STRUCT_ARG = ( # pyright: ignore[reportUnknownVariableType] - 18, +XML_TIMESTAMPS: StaticOperationSchema = ( + 23, n0, - _SA, + _XT, 0, - (_SAt, _OA, _RA), - ( - (3, 0), - (2, 0), - (lambda: STRUCT_ARG, 0), # pyright: ignore[reportUnknownLambdaType] - ), + XML_TIMESTAMPS_INPUT, + XML_TIMESTAMPS_OUTPUT, + (), ) -NESTED_STRUCTURES_INPUT = ( # pyright: ignore[reportUnknownVariableType] +STRUCT_ARG: StaticSchema = ( 18, n0, - _NSI, + _SA, 0, - (_N,), - ((STRUCT_ARG, 0),), + (_SAt, _OA, _RA), + ((3, 0), (2, 0), (lambda: STRUCT_ARG, 0)), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] +NESTED_STRUCTURES_INPUT: StaticSchema = (18, n0, _NSI, 0, (_N,), ((STRUCT_ARG, 0),)) + +RECURSIVE_XML_SHAPES_OUTPUT_NESTED1: StaticSchema = ( 18, n0, _RXSON, 0, (_f, _n), - ( - (3, 0), - (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] - ), + ((3, 0), (lambda: RECURSIVE_XML_SHAPES_OUTPUT_NESTED2, 0)), ) -RECURSIVE_XML_SHAPES_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_XML_SHAPES_OUTPUT_NESTED2: StaticSchema = ( 18, n0, _RXSONe, @@ -806,7 +931,7 @@ ((3, 0), (RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0)), ) -NESTED_STRUCTURES = ( # pyright: ignore[reportUnknownVariableType] +NESTED_STRUCTURES: StaticOperationSchema = ( 23, n0, _NS, @@ -816,7 +941,7 @@ (), ) -RECURSIVE_XML_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_XML_SHAPES_OUTPUT: StaticSchema = ( 18, n0, _RXSO, @@ -825,7 +950,7 @@ ((RECURSIVE_XML_SHAPES_OUTPUT_NESTED1, 0),), ) -RECURSIVE_XML_SHAPES = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_XML_SHAPES: StaticOperationSchema = ( 23, n0, _RXS, @@ -835,7 +960,7 @@ (), ) -AWS_EC2 = ( +AWS_EC2: StaticSchema = ( 21, n0, _AE, @@ -991,8 +1116,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1004,8 +1129,8 @@ "endpoint": MappingProxyType( { "url": "https://awsec2-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1024,8 +1149,8 @@ "endpoint": MappingProxyType( { "url": "https://awsec2.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1037,8 +1162,8 @@ "endpoint": MappingProxyType( { "url": "https://awsec2-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1057,8 +1182,8 @@ "endpoint": MappingProxyType( { "url": "https://awsec2.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -1077,8 +1202,8 @@ "endpoint": MappingProxyType( { "url": "https://awsec2.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/rest-json-1/src/restjson/_private/schemas.py b/codegen-output/rest-json-1/src/restjson/_private/schemas.py index 2fa47299d..b789ab6f5 100644 --- a/codegen-output/rest-json-1/src/restjson/_private/schemas.py +++ b/codegen-output/rest-json-1/src/restjson/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.shared" _BL = "BooleanList" @@ -838,11 +840,11 @@ _aws = "aws.api#service" _aJ = "aws.protocols#restJson1" -BOOLEAN_LIST = (16, n0, _BL, 0, (_m,), ((2, 0),)) +BOOLEAN_LIST: StaticSchema = (16, n0, _BL, 0, (_m,), ((2, 0),)) -DOUBLE_LIST = (16, n0, _DL, 0, (_m,), ((10, 0),)) +DOUBLE_LIST: StaticSchema = (16, n0, _DL, 0, (_m,), ((10, 0),)) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n0, _FE, @@ -851,25 +853,25 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -FOO_ENUM_LIST = (16, n0, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_LIST: StaticSchema = (16, n0, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -INTEGER_ENUM = (15, n0, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = (15, n0, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -INTEGER_ENUM_LIST = (16, n0, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_LIST: StaticSchema = (16, n0, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -INTEGER_LIST = (16, n0, _IL, 0, (_m,), ((7, 0),)) +INTEGER_LIST: StaticSchema = (16, n0, _IL, 0, (_m,), ((7, 0),)) -INTEGER_SET = (16, n0, _IS, 0, (_m,), ((7, 0),)) +INTEGER_SET: StaticSchema = (16, n0, _IS, 0, (_m,), ((7, 0),)) -STRING_LIST = (16, n0, _SL, 0, (_m,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n0, _SL, 0, (_m,), ((3, 0),)) -STRING_LIST_MAP = (17, n0, _SLM, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) +STRING_LIST_MAP: StaticSchema = (17, n0, _SLM, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) -STRING_SET = (16, n0, _SS, 0, (_m,), ((3, 0),)) +STRING_SET: StaticSchema = (16, n0, _SS, 0, (_m,), ((3, 0),)) -TIMESTAMP_LIST = (16, n0, _TL, 0, (_m,), ((4, 0),)) +TIMESTAMP_LIST: StaticSchema = (16, n0, _TL, 0, (_m,), ((4, 0),)) -ALL_QUERY_STRING_TYPES_INPUT = ( +ALL_QUERY_STRING_TYPES_INPUT: StaticSchema = ( 18, n1, _AQSTI, @@ -922,9 +924,9 @@ ), ) -ALL_QUERY_STRING_TYPES_OUTPUT = (18, n1, _AQSTO, {_sSI: _sU}) +ALL_QUERY_STRING_TYPES_OUTPUT: StaticSchema = (18, n1, _AQSTO, {_sSI: _sU}) -ALL_QUERY_STRING_TYPES = ( +ALL_QUERY_STRING_TYPES: StaticOperationSchema = ( 23, n1, _AQST, @@ -934,13 +936,20 @@ (), ) -BLOB_PAYLOAD_EVENT = (18, n1, _BPE, 0, (_p,), ((1, {_sP: None}),)) +BLOB_PAYLOAD_EVENT: StaticSchema = (18, n1, _BPE, 0, (_p,), ((1, {_sP: None}),)) -CLIENT_OPTIONAL_DEFAULTS = (18, n1, _COD, 0, (_m,), ((7, {_sm: 0}),)) +CLIENT_OPTIONAL_DEFAULTS: StaticSchema = (18, n1, _COD, 0, (_m,), ((7, {_sm: 0}),)) -COMPLEX_NESTED_ERROR_DATA = (18, n1, _CNED, 0, (_Fo,), ((3, {_sN: _Foo}),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = ( + 18, + n1, + _CNED, + 0, + (_Fo,), + ((3, {_sN: _Foo}),), +) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n1, _CE, @@ -949,7 +958,7 @@ ((3, {_sH: _XH}), (3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT = ( +CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT: StaticSchema = ( 18, n1, _CAVQSI, @@ -958,9 +967,9 @@ ((3, {_sQ: _b}), (3, {_sQ: _mS})), ) -CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT = (18, n1, _CAVQSO, {_sSI: _sU}) +CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT: StaticSchema = (18, n1, _CAVQSO, {_sSI: _sU}) -CONSTANT_AND_VARIABLE_QUERY_STRING = ( +CONSTANT_AND_VARIABLE_QUERY_STRING: StaticOperationSchema = ( 23, n1, _CAVQS, @@ -974,11 +983,11 @@ (), ) -CONSTANT_QUERY_STRING_INPUT = (18, n1, _CQSI, 0, (_h,), ((3, 9),)) +CONSTANT_QUERY_STRING_INPUT: StaticSchema = (18, n1, _CQSI, 0, (_h,), ((3, 9),)) -CONSTANT_QUERY_STRING_OUTPUT = (18, n1, _CQSO, {_sSI: _sU}) +CONSTANT_QUERY_STRING_OUTPUT: StaticSchema = (18, n1, _CQSO, {_sSI: _sU}) -CONSTANT_QUERY_STRING = ( +CONSTANT_QUERY_STRING: StaticOperationSchema = ( 23, n1, _CQS, @@ -992,11 +1001,11 @@ (), ) -CONTENT_TYPE_PARAMETERS_INPUT = (18, n1, _CTPI, 0, (_v,), ((7, 0),)) +CONTENT_TYPE_PARAMETERS_INPUT: StaticSchema = (18, n1, _CTPI, 0, (_v,), ((7, 0),)) -CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n1, _CTPO, 0) +CONTENT_TYPE_PARAMETERS_OUTPUT: StaticSchema = (18, n1, _CTPO, 0) -CONTENT_TYPE_PARAMETERS = ( +CONTENT_TYPE_PARAMETERS: StaticOperationSchema = ( 23, n1, _CTP, @@ -1006,13 +1015,13 @@ (), ) -DATETIME_OFFSETS_INPUT = (18, n1, _DOI, {_sSI: _sU}) +DATETIME_OFFSETS_INPUT: StaticSchema = (18, n1, _DOI, {_sSI: _sU}) -DATE_TIME = (4, n0, _DT, {_sF: _dt}) +DATE_TIME: StaticSchema = (4, n0, _DT, {_sF: _dt}) -DATETIME_OFFSETS_OUTPUT = (18, n1, _DOO, 0, (_d,), ((DATE_TIME, 0),)) +DATETIME_OFFSETS_OUTPUT: StaticSchema = (18, n1, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -DATETIME_OFFSETS = ( +DATETIME_OFFSETS: StaticOperationSchema = ( 23, n1, _DO, @@ -1022,17 +1031,24 @@ (), ) -DOCUMENT = (13, n1, _Do, 0) +DOCUMENT: StaticSchema = (13, n1, _Do, 0) -TEST_ENUM = (14, n1, _TE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) +TEST_ENUM: StaticSchema = ( + 14, + n1, + _TE, + 0, + (_FOO, _BAR, _BAZ), + ((-1, 0), (-1, 0), (-1, 0)), +) -TEST_INT_ENUM = (15, n1, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) +TEST_INT_ENUM: StaticSchema = (15, n1, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) -TEST_STRING_LIST = (16, n1, _TSL, 0, (_m,), ((3, 0),)) +TEST_STRING_LIST: StaticSchema = (16, n1, _TSL, 0, (_m,), ((3, 0),)) -TEST_STRING_MAP = (17, n1, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) +TEST_STRING_MAP: StaticSchema = (17, n1, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) -DEFAULTS = ( +DEFAULTS: StaticSchema = ( 18, n1, _De, @@ -1099,27 +1115,41 @@ ), ) -DENSE_BOOLEAN_MAP = (17, n1, _DBM, 0, (_k, _v), ((3, 0), (2, 0))) +DENSE_BOOLEAN_MAP: StaticSchema = (17, n1, _DBM, 0, (_k, _v), ((3, 0), (2, 0))) -DENSE_NUMBER_MAP = (17, n1, _DNM, 0, (_k, _v), ((3, 0), (7, 0))) +DENSE_NUMBER_MAP: StaticSchema = (17, n1, _DNM, 0, (_k, _v), ((3, 0), (7, 0))) -DENSE_SET_MAP = (17, n1, _DSM, 0, (_k, _v), ((3, 0), (STRING_SET, 0))) +DENSE_SET_MAP: StaticSchema = (17, n1, _DSM, 0, (_k, _v), ((3, 0), (STRING_SET, 0))) -DENSE_STRING_MAP = (17, n1, _DSMe, 0, (_k, _v), ((3, 0), (3, 0))) +DENSE_STRING_MAP: StaticSchema = (17, n1, _DSMe, 0, (_k, _v), ((3, 0), (3, 0))) -GREETING_STRUCT = (18, n0, _GS, 0, (_hi,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n0, _GS, 0, (_hi,), ((3, 0),)) -DENSE_STRUCT_MAP = (17, n1, _DSMen, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) +DENSE_STRUCT_MAP: StaticSchema = ( + 17, + n1, + _DSMen, + 0, + (_k, _v), + ((3, 0), (GREETING_STRUCT, 0)), +) -FAREWELL = (18, n1, _Fa, 0, (_ph,), ((3, {_sm: _by}),)) +FAREWELL: StaticSchema = (18, n1, _Fa, 0, (_ph,), ((3, {_sm: _by}),)) -DIALOG = (18, n1, _Di, 0, (_l, _g, _f), ((3, 0), (3, {_sm: _hi}), (FAREWELL, 0))) +DIALOG: StaticSchema = ( + 18, + n1, + _Di, + 0, + (_l, _g, _f), + ((3, 0), (3, {_sm: _hi}), (FAREWELL, 0)), +) -DIALOG_LIST = (16, n1, _DLi, 0, (_m,), ((DIALOG, 0),)) +DIALOG_LIST: StaticSchema = (16, n1, _DLi, 0, (_m,), ((DIALOG, 0),)) -DIALOG_MAP = (17, n1, _DM, 0, (_k, _v), ((3, 0), (DIALOG, 0))) +DIALOG_MAP: StaticSchema = (17, n1, _DM, 0, (_k, _v), ((3, 0), (DIALOG, 0))) -DOCUMENT_TYPE_INPUT = ( +DOCUMENT_TYPE_INPUT: StaticSchema = ( 18, n1, _DTI, @@ -1128,7 +1158,7 @@ ((3, 0), (DOCUMENT, 0)), ) -DOCUMENT_TYPE_OUTPUT = ( +DOCUMENT_TYPE_OUTPUT: StaticSchema = ( 18, n1, _DTO, @@ -1137,7 +1167,7 @@ ((3, 0), (DOCUMENT, 0)), ) -DOCUMENT_TYPE = ( +DOCUMENT_TYPE: StaticOperationSchema = ( 23, n1, _DTo, @@ -1147,9 +1177,9 @@ (), ) -DOCUMENT_VALUED_MAP = (17, n1, _DVM, 0, (_k, _v), ((3, 0), (DOCUMENT, 0))) +DOCUMENT_VALUED_MAP: StaticSchema = (17, n1, _DVM, 0, (_k, _v), ((3, 0), (DOCUMENT, 0))) -DOCUMENT_TYPE_AS_MAP_VALUE_INPUT = ( +DOCUMENT_TYPE_AS_MAP_VALUE_INPUT: StaticSchema = ( 18, n1, _DTAMVI, @@ -1158,7 +1188,7 @@ ((DOCUMENT_VALUED_MAP, 0),), ) -DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT = ( +DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT: StaticSchema = ( 18, n1, _DTAMVO, @@ -1167,7 +1197,7 @@ ((DOCUMENT_VALUED_MAP, 0),), ) -DOCUMENT_TYPE_AS_MAP_VALUE = ( +DOCUMENT_TYPE_AS_MAP_VALUE: StaticOperationSchema = ( 23, n1, _DTAMV, @@ -1177,7 +1207,7 @@ (), ) -DOCUMENT_TYPE_AS_PAYLOAD_INPUT = ( +DOCUMENT_TYPE_AS_PAYLOAD_INPUT: StaticSchema = ( 18, n1, _DTAPI, @@ -1186,7 +1216,7 @@ ((DOCUMENT, 16),), ) -DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT = ( +DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT: StaticSchema = ( 18, n1, _DTAPO, @@ -1195,7 +1225,7 @@ ((DOCUMENT, 16),), ) -DOCUMENT_TYPE_AS_PAYLOAD = ( +DOCUMENT_TYPE_AS_PAYLOAD: StaticOperationSchema = ( 23, n1, _DTAP, @@ -1205,9 +1235,9 @@ (), ) -ERROR_EVENT = (18, n1, _EE, {_smi: _c}, (_me,), ((3, 0),)) +ERROR_EVENT: StaticSchema = (18, n1, _EE, {_smi: _c}, (_me,), ((3, 0),)) -HEADERS_EVENT = ( +HEADERS_EVENT: StaticSchema = ( 18, n1, _HE, @@ -1225,9 +1255,9 @@ ), ) -PAYLOAD_STRUCTURE = (18, n1, _PS, 0, (_sM,), ((3, 0),)) +PAYLOAD_STRUCTURE: StaticSchema = (18, n1, _PS, 0, (_sM,), ((3, 0),)) -HEADERS_AND_EXPLICIT_PAYLOAD_EVENT = ( +HEADERS_AND_EXPLICIT_PAYLOAD_EVENT: StaticSchema = ( 18, n1, _HAEPE, @@ -1236,7 +1266,7 @@ ((3, {_sHm: None}), (PAYLOAD_STRUCTURE, {_sP: None})), ) -HEADERS_AND_IMPLICIT_PAYLOAD_EVENT = ( +HEADERS_AND_IMPLICIT_PAYLOAD_EVENT: StaticSchema = ( 18, n1, _HAIPE, @@ -1245,15 +1275,29 @@ ((3, {_sHm: None}), (3, 0)), ) -STRING_PAYLOAD_EVENT = (18, n1, _SPE, 0, (_p,), ((3, {_sP: None}),)) +STRING_PAYLOAD_EVENT: StaticSchema = (18, n1, _SPE, 0, (_p,), ((3, {_sP: None}),)) -STRUCTURE_PAYLOAD_EVENT = (18, n1, _SPEt, 0, (_p,), ((PAYLOAD_STRUCTURE, {_sP: None}),)) +STRUCTURE_PAYLOAD_EVENT: StaticSchema = ( + 18, + n1, + _SPEt, + 0, + (_p,), + ((PAYLOAD_STRUCTURE, {_sP: None}),), +) -PAYLOAD_UNION = (19, n1, _PU, 0, (_uM,), ((3, 0),)) +PAYLOAD_UNION: StaticSchema = (19, n1, _PU, 0, (_uM,), ((3, 0),)) -UNION_PAYLOAD_EVENT = (18, n1, _UPE, 0, (_p,), ((PAYLOAD_UNION, {_sP: None}),)) +UNION_PAYLOAD_EVENT: StaticSchema = ( + 18, + n1, + _UPE, + 0, + (_p,), + ((PAYLOAD_UNION, {_sP: None}),), +) -EVENT_STREAM = ( +EVENT_STREAM: StaticSchema = ( 19, n1, _ES, @@ -1271,11 +1315,11 @@ ), ) -DUPLEX_STREAM_INPUT = (18, n1, _DSI, 0, (_st,), ((EVENT_STREAM, 16),)) +DUPLEX_STREAM_INPUT: StaticSchema = (18, n1, _DSI, 0, (_st,), ((EVENT_STREAM, 16),)) -DUPLEX_STREAM_OUTPUT = (18, n1, _DSO, 0, (_st,), ((EVENT_STREAM, 16),)) +DUPLEX_STREAM_OUTPUT: StaticSchema = (18, n1, _DSO, 0, (_st,), ((EVENT_STREAM, 16),)) -DUPLEX_STREAM = ( +DUPLEX_STREAM: StaticOperationSchema = ( 23, n1, _DS, @@ -1285,7 +1329,7 @@ (), ) -DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT = ( +DUPLEX_STREAM_WITH_DISTINCT_STREAMS_INPUT: StaticSchema = ( 18, n1, _DSWDSI, @@ -1294,11 +1338,18 @@ ((EVENT_STREAM, 16),), ) -SINGLETON_EVENT = (18, n1, _SE, 0, (_v,), ((3, 0),)) +SINGLETON_EVENT: StaticSchema = (18, n1, _SE, 0, (_v,), ((3, 0),)) -SINGLETON_EVENT_STREAM = (19, n1, _SES, 0, (_si,), ((SINGLETON_EVENT, 0),)) +SINGLETON_EVENT_STREAM: StaticSchema = ( + 19, + n1, + _SES, + 0, + (_si,), + ((SINGLETON_EVENT, 0),), +) -DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT = ( +DUPLEX_STREAM_WITH_DISTINCT_STREAMS_OUTPUT: StaticSchema = ( 18, n1, _DSWDSO, @@ -1307,7 +1358,7 @@ ((SINGLETON_EVENT_STREAM, 16),), ) -DUPLEX_STREAM_WITH_DISTINCT_STREAMS = ( +DUPLEX_STREAM_WITH_DISTINCT_STREAMS: StaticOperationSchema = ( 23, n1, _DSWDS, @@ -1321,7 +1372,7 @@ (), ) -DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT = ( +DUPLEX_STREAM_WITH_INITIAL_MESSAGES_INPUT: StaticSchema = ( 18, n1, _DSWIMI, @@ -1330,7 +1381,7 @@ ((3, {_sH: _irm, _smit: None}), (EVENT_STREAM, 16)), ) -DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT = ( +DUPLEX_STREAM_WITH_INITIAL_MESSAGES_OUTPUT: StaticSchema = ( 18, n1, _DSWIMO, @@ -1339,9 +1390,16 @@ ((3, {_sH: _irm_, _smit: None}), (EVENT_STREAM, 16)), ) -SERVICE_UNAVAILABLE_ERROR = (18, n1, _SUE, {_smi: _se, _sE: 500}, (_me,), ((3, 0),)) +SERVICE_UNAVAILABLE_ERROR: StaticSchema = ( + 18, + n1, + _SUE, + {_smi: _se, _sE: 500}, + (_me,), + ((3, 0),), +) -DUPLEX_STREAM_WITH_INITIAL_MESSAGES = ( +DUPLEX_STREAM_WITH_INITIAL_MESSAGES: StaticOperationSchema = ( 23, n1, _DSWIM, @@ -1355,11 +1413,11 @@ (SERVICE_UNAVAILABLE_ERROR,), ) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n1, _EIAEOI, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT: StaticSchema = (18, n1, _EIAEOI, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n1, _EIAEOO, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT: StaticSchema = (18, n1, _EIAEOO, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT = ( +EMPTY_INPUT_AND_EMPTY_OUTPUT: StaticOperationSchema = ( 23, n1, _EIAEO, @@ -1369,11 +1427,11 @@ (), ) -ENDPOINT_OPERATION_INPUT = (18, n1, _EOI, {_sSI: _sU}) +ENDPOINT_OPERATION_INPUT: StaticSchema = (18, n1, _EOI, {_sSI: _sU}) -ENDPOINT_OPERATION_OUTPUT = (18, n1, _EOO, {_sSI: _sU}) +ENDPOINT_OPERATION_OUTPUT: StaticSchema = (18, n1, _EOO, {_sSI: _sU}) -ENDPOINT_OPERATION = ( +ENDPOINT_OPERATION: StaticOperationSchema = ( 23, n1, _EO, @@ -1386,7 +1444,7 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( 18, n1, _EWHLOI, @@ -1395,9 +1453,9 @@ ((3, 257),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n1, _EWHLOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = (18, n1, _EWHLOO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( 23, n1, _EWHLO, @@ -1412,15 +1470,15 @@ (), ) -FINITE_STREAMING_BLOB = (1, n1, _FSB, {_smith: None, _sLmi: None}) +FINITE_STREAMING_BLOB: StaticSchema = (1, n1, _FSB, {_smith: None, _sLmi: None}) -FOO_ERROR = (18, n1, _FEo, {_smi: _se, _sE: 500}) +FOO_ERROR: StaticSchema = (18, n1, _FEo, {_smi: _se, _sE: 500}) -FRACTIONAL_SECONDS_INPUT = (18, n1, _FSI, {_sSI: _sU}) +FRACTIONAL_SECONDS_INPUT: StaticSchema = (18, n1, _FSI, {_sSI: _sU}) -FRACTIONAL_SECONDS_OUTPUT = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -FRACTIONAL_SECONDS = ( +FRACTIONAL_SECONDS: StaticOperationSchema = ( 23, n1, _FS, @@ -1430,13 +1488,20 @@ (), ) -GREETING_WITH_ERRORS_INPUT = (18, n1, _GWEI, {_sSI: _sU}) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n1, _GWEI, {_sSI: _sU}) -GREETING_WITH_ERRORS_OUTPUT = (18, n1, _GWEO, 0, (_g,), ((3, {_sH: _XG}),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = ( + 18, + n1, + _GWEO, + 0, + (_g,), + ((3, {_sH: _XG}),), +) -INVALID_GREETING = (18, n1, _IG, {_smi: _c, _sE: 400}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n1, _IG, {_smi: _c, _sE: 400}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n1, _GWE, @@ -1446,11 +1511,11 @@ (INVALID_GREETING, COMPLEX_ERROR, FOO_ERROR), ) -HOST_WITH_PATH_OPERATION_INPUT = (18, n1, _HWPOI, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_INPUT: StaticSchema = (18, n1, _HWPOI, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION_OUTPUT = (18, n1, _HWPOO, {_sSI: _sU}) +HOST_WITH_PATH_OPERATION_OUTPUT: StaticSchema = (18, n1, _HWPOO, {_sSI: _sU}) -HOST_WITH_PATH_OPERATION = ( +HOST_WITH_PATH_OPERATION: StaticOperationSchema = ( 23, n1, _HWPO, @@ -1460,11 +1525,25 @@ (), ) -HTTP_CHECKSUM_REQUIRED_INPUT = (18, n1, _HCRI, {_sSI: _aHCRIO}, (_fo,), ((3, 0),)) +HTTP_CHECKSUM_REQUIRED_INPUT: StaticSchema = ( + 18, + n1, + _HCRI, + {_sSI: _aHCRIO}, + (_fo,), + ((3, 0),), +) -HTTP_CHECKSUM_REQUIRED_OUTPUT = (18, n1, _HCRO, {_sSI: _aHCRIO}, (_fo,), ((3, 0),)) +HTTP_CHECKSUM_REQUIRED_OUTPUT: StaticSchema = ( + 18, + n1, + _HCRO, + {_sSI: _aHCRIO}, + (_fo,), + ((3, 0),), +) -HTTP_CHECKSUM_REQUIRED = ( +HTTP_CHECKSUM_REQUIRED: StaticOperationSchema = ( 23, n1, _HCR, @@ -1477,9 +1556,9 @@ (), ) -STRING_MAP = (17, n0, _SM, 0, (_k, _v), ((3, 0), (3, 0))) +STRING_MAP: StaticSchema = (17, n0, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -HTTP_EMPTY_PREFIX_HEADERS_INPUT = ( +HTTP_EMPTY_PREFIX_HEADERS_INPUT: StaticSchema = ( 18, n1, _HEPHI, @@ -1488,7 +1567,7 @@ ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -HTTP_EMPTY_PREFIX_HEADERS_OUTPUT = ( +HTTP_EMPTY_PREFIX_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _HEPHO, @@ -1497,7 +1576,7 @@ ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -HTTP_EMPTY_PREFIX_HEADERS = ( +HTTP_EMPTY_PREFIX_HEADERS: StaticOperationSchema = ( 23, n1, _HEPH, @@ -1507,13 +1586,27 @@ (), ) -STRING_ENUM = (14, n1, _SEt, 0, (_V,), ((-1, 0),)) +STRING_ENUM: StaticSchema = (14, n1, _SEt, 0, (_V,), ((-1, 0),)) -HTTP_ENUM_PAYLOAD_INPUT = (18, n1, _HEPI, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) +HTTP_ENUM_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _HEPI, + {_sSI: _aEPI}, + (_p,), + ((STRING_ENUM, 16),), +) -HTTP_ENUM_PAYLOAD_OUTPUT = (18, n1, _HEPO, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) +HTTP_ENUM_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _HEPO, + {_sSI: _aEPI}, + (_p,), + ((STRING_ENUM, 16),), +) -HTTP_ENUM_PAYLOAD = ( +HTTP_ENUM_PAYLOAD: StaticOperationSchema = ( 23, n1, _HEP, @@ -1523,7 +1616,7 @@ (), ) -HTTP_PAYLOAD_TRAITS_INPUT = ( +HTTP_PAYLOAD_TRAITS_INPUT: StaticSchema = ( 18, n1, _HPTI, @@ -1532,7 +1625,7 @@ ((3, {_sH: _XF}), (1, 16)), ) -HTTP_PAYLOAD_TRAITS_OUTPUT = ( +HTTP_PAYLOAD_TRAITS_OUTPUT: StaticSchema = ( 18, n1, _HPTO, @@ -1541,7 +1634,7 @@ ((3, {_sH: _XF}), (1, 16)), ) -HTTP_PAYLOAD_TRAITS = ( +HTTP_PAYLOAD_TRAITS: StaticOperationSchema = ( 23, n1, _HPT, @@ -1551,9 +1644,9 @@ (), ) -TEXT_PLAIN_BLOB = (1, n0, _TPB, {_sT: _t}) +TEXT_PLAIN_BLOB: StaticSchema = (1, n0, _TPB, {_sT: _t}) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT = ( +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT: StaticSchema = ( 18, n1, _HPTWMTI, @@ -1562,7 +1655,7 @@ ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT = ( +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT: StaticSchema = ( 18, n1, _HPTWMTO, @@ -1571,7 +1664,7 @@ ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = ( +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE: StaticOperationSchema = ( 23, n1, _HPTWMT, @@ -1585,9 +1678,9 @@ (), ) -NESTED_PAYLOAD = (18, n1, _NP, 0, (_g, _n), ((3, 0), (3, 0))) +NESTED_PAYLOAD: StaticSchema = (18, n1, _NP, 0, (_g, _n), ((3, 0), (3, 0))) -HTTP_PAYLOAD_WITH_STRUCTURE_INPUT = ( +HTTP_PAYLOAD_WITH_STRUCTURE_INPUT: StaticSchema = ( 18, n1, _HPWSI, @@ -1596,7 +1689,7 @@ ((NESTED_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT = ( +HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT: StaticSchema = ( 18, n1, _HPWSO, @@ -1605,7 +1698,7 @@ ((NESTED_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_STRUCTURE = ( +HTTP_PAYLOAD_WITH_STRUCTURE: StaticOperationSchema = ( 23, n1, _HPWS, @@ -1615,9 +1708,9 @@ (), ) -UNION_PAYLOAD = (19, n1, _UP, 0, (_g,), ((3, 0),)) +UNION_PAYLOAD: StaticSchema = (19, n1, _UP, 0, (_g,), ((3, 0),)) -HTTP_PAYLOAD_WITH_UNION_INPUT = ( +HTTP_PAYLOAD_WITH_UNION_INPUT: StaticSchema = ( 18, n1, _HPWUI, @@ -1626,7 +1719,7 @@ ((UNION_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_UNION_OUTPUT = ( +HTTP_PAYLOAD_WITH_UNION_OUTPUT: StaticSchema = ( 18, n1, _HPWUO, @@ -1635,7 +1728,7 @@ ((UNION_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_UNION = ( +HTTP_PAYLOAD_WITH_UNION: StaticOperationSchema = ( 23, n1, _HPWU, @@ -1645,7 +1738,7 @@ (), ) -HTTP_PREFIX_HEADERS_INPUT = ( +HTTP_PREFIX_HEADERS_INPUT: StaticSchema = ( 18, n1, _HPHI, @@ -1654,7 +1747,7 @@ ((3, {_sH: _xf}), (STRING_MAP, {_sPH: _xf_})), ) -HTTP_PREFIX_HEADERS_OUTPUT = ( +HTTP_PREFIX_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _HPHO, @@ -1663,7 +1756,7 @@ ((3, {_sH: _xf}), (STRING_MAP, {_sPH: _xf_})), ) -HTTP_PREFIX_HEADERS = ( +HTTP_PREFIX_HEADERS: StaticOperationSchema = ( 23, n1, _HPH, @@ -1673,9 +1766,9 @@ (), ) -HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT = (18, n1, _HPHIRI, 0) +HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT: StaticSchema = (18, n1, _HPHIRI, 0) -HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT = ( +HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT: StaticSchema = ( 18, n1, _HPHIRO, @@ -1684,7 +1777,7 @@ ((STRING_MAP, {_sPH: _v_}),), ) -HTTP_PREFIX_HEADERS_IN_RESPONSE = ( +HTTP_PREFIX_HEADERS_IN_RESPONSE: StaticOperationSchema = ( 23, n1, _HPHIR, @@ -1694,9 +1787,9 @@ (), ) -QUERY_MAP = (17, n1, _QM, 0, (_k, _v), ((3, 0), (3, 0))) +QUERY_MAP: StaticSchema = (17, n1, _QM, 0, (_k, _v), ((3, 0), (3, 0))) -HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT = ( +HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT: StaticSchema = ( 18, n1, _HQPOOI, @@ -1705,9 +1798,9 @@ ((QUERY_MAP, 1024),), ) -HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT = (18, n1, _HQPOOO, {_sSI: _sU}) +HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT: StaticSchema = (18, n1, _HQPOOO, {_sSI: _sU}) -HTTP_QUERY_PARAMS_ONLY_OPERATION = ( +HTTP_QUERY_PARAMS_ONLY_OPERATION: StaticOperationSchema = ( 23, n1, _HQPOO, @@ -1717,7 +1810,7 @@ (), ) -HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT = ( +HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT: StaticSchema = ( 18, n1, _HRWFLI, @@ -1726,9 +1819,9 @@ ((9, 9), (10, 9)), ) -HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT = (18, n1, _HRWFLO, {_sSI: _sU}) +HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT: StaticSchema = (18, n1, _HRWFLO, {_sSI: _sU}) -HTTP_REQUEST_WITH_FLOAT_LABELS = ( +HTTP_REQUEST_WITH_FLOAT_LABELS: StaticOperationSchema = ( 23, n1, _HRWFL, @@ -1742,7 +1835,7 @@ (), ) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT = ( +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT: StaticSchema = ( 18, n1, _HRWGLIPI, @@ -1751,9 +1844,14 @@ ((3, 9), (3, 9)), ) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT = (18, n1, _HRWGLIPO, {_sSI: _sU}) +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT: StaticSchema = ( + 18, + n1, + _HRWGLIPO, + {_sSI: _sU}, +) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = ( +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH: StaticOperationSchema = ( 23, n1, _HRWGLIP, @@ -1770,7 +1868,7 @@ (), ) -HTTP_REQUEST_WITH_LABELS_INPUT = ( +HTTP_REQUEST_WITH_LABELS_INPUT: StaticSchema = ( 18, n1, _HRWLI, @@ -1779,9 +1877,9 @@ ((3, 9), (6, 9), (7, 9), (8, 9), (9, 9), (10, 9), (2, 9), (4, 9)), ) -HTTP_REQUEST_WITH_LABELS_OUTPUT = (18, n1, _HRWLO, {_sSI: _sU}) +HTTP_REQUEST_WITH_LABELS_OUTPUT: StaticSchema = (18, n1, _HRWLO, {_sSI: _sU}) -HTTP_REQUEST_WITH_LABELS = ( +HTTP_REQUEST_WITH_LABELS: StaticOperationSchema = ( 23, n1, _HRWL, @@ -1798,11 +1896,11 @@ (), ) -EPOCH_SECONDS = (4, n0, _ESp, {_sF: _es}) +EPOCH_SECONDS: StaticSchema = (4, n0, _ESp, {_sF: _es}) -HTTP_DATE = (4, n0, _HD, {_sF: _hd}) +HTTP_DATE: StaticSchema = (4, n0, _HD, {_sF: _hd}) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT = ( +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT: StaticSchema = ( 18, n1, _HRWLATFI, @@ -1819,9 +1917,14 @@ ), ) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT = (18, n1, _HRWLATFO, {_sSI: _sU}) +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT: StaticSchema = ( + 18, + n1, + _HRWLATFO, + {_sSI: _sU}, +) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = ( +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT: StaticOperationSchema = ( 23, n1, _HRWLATF, @@ -1838,11 +1941,18 @@ (), ) -HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT = (18, n1, _HRWRLI, 0, (_str_,), ((3, 9),)) +HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT: StaticSchema = ( + 18, + n1, + _HRWRLI, + 0, + (_str_,), + ((3, 9),), +) -HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT = (18, n1, _HRWRLO, {_sSI: _sU}) +HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT: StaticSchema = (18, n1, _HRWRLO, {_sSI: _sU}) -HTTP_REQUEST_WITH_REGEX_LITERAL = ( +HTTP_REQUEST_WITH_REGEX_LITERAL: StaticOperationSchema = ( 23, n1, _HRWRL, @@ -1852,11 +1962,11 @@ (), ) -HTTP_RESPONSE_CODE_INPUT = (18, n1, _HRCI, {_sSI: _sU}) +HTTP_RESPONSE_CODE_INPUT: StaticSchema = (18, n1, _HRCI, {_sSI: _sU}) -HTTP_RESPONSE_CODE_OUTPUT = (18, n1, _HRCO, 0, (_St,), ((7, 128),)) +HTTP_RESPONSE_CODE_OUTPUT: StaticSchema = (18, n1, _HRCO, 0, (_St,), ((7, 128),)) -HTTP_RESPONSE_CODE = ( +HTTP_RESPONSE_CODE: StaticOperationSchema = ( 23, n1, _HRC, @@ -1866,11 +1976,25 @@ (), ) -HTTP_STRING_PAYLOAD_INPUT = (18, n1, _HSPI, {_sSI: _aSPI}, (_p,), ((3, 16),)) +HTTP_STRING_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _HSPI, + {_sSI: _aSPI}, + (_p,), + ((3, 16),), +) -HTTP_STRING_PAYLOAD_OUTPUT = (18, n1, _HSPO, {_sSI: _aSPI}, (_p,), ((3, 16),)) +HTTP_STRING_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _HSPO, + {_sSI: _aSPI}, + (_p,), + ((3, 16),), +) -HTTP_STRING_PAYLOAD = ( +HTTP_STRING_PAYLOAD: StaticOperationSchema = ( 23, n1, _HSP, @@ -1880,11 +2004,18 @@ (), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT = (18, n1, _IQPIRI, {_sSI: _sU}) +IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT: StaticSchema = (18, n1, _IQPIRI, {_sSI: _sU}) -IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT = (18, n1, _IQPIRO, 0, (_b,), ((3, {_sQ: _b}),)) +IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT: StaticSchema = ( + 18, + n1, + _IQPIRO, + 0, + (_b,), + ((3, {_sQ: _b}),), +) -IGNORE_QUERY_PARAMS_IN_RESPONSE = ( +IGNORE_QUERY_PARAMS_IN_RESPONSE: StaticOperationSchema = ( 23, n1, _IQPIR, @@ -1894,7 +2025,7 @@ (), ) -INPUT_AND_OUTPUT_WITH_HEADERS_INPUT = ( +INPUT_AND_OUTPUT_WITH_HEADERS_INPUT: StaticSchema = ( 18, n1, _IAOWHI, @@ -1941,7 +2072,7 @@ ), ) -INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT = ( +INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _IAOWHO, @@ -1988,7 +2119,7 @@ ), ) -INPUT_AND_OUTPUT_WITH_HEADERS = ( +INPUT_AND_OUTPUT_WITH_HEADERS: StaticOperationSchema = ( 23, n1, _IAOWH, @@ -1998,11 +2129,11 @@ (), ) -INPUT_STREAM_INPUT = (18, n1, _ISI, 0, (_st,), ((EVENT_STREAM, 16),)) +INPUT_STREAM_INPUT: StaticSchema = (18, n1, _ISI, 0, (_st,), ((EVENT_STREAM, 16),)) -INPUT_STREAM_OUTPUT = (18, n1, _ISO, {_sSI: _sU}) +INPUT_STREAM_OUTPUT: StaticSchema = (18, n1, _ISO, {_sSI: _sU}) -INPUT_STREAM = ( +INPUT_STREAM: StaticOperationSchema = ( 23, n1, _ISn, @@ -2012,7 +2143,7 @@ (), ) -INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT = ( +INPUT_STREAM_WITH_INITIAL_REQUEST_INPUT: StaticSchema = ( 18, n1, _ISWIRI, @@ -2021,9 +2152,9 @@ ((3, {_sH: _irm, _smit: None}), (EVENT_STREAM, 16)), ) -INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT = (18, n1, _ISWIRO, {_sSI: _sU}) +INPUT_STREAM_WITH_INITIAL_REQUEST_OUTPUT: StaticSchema = (18, n1, _ISWIRO, {_sSI: _sU}) -INPUT_STREAM_WITH_INITIAL_REQUEST = ( +INPUT_STREAM_WITH_INITIAL_REQUEST: StaticOperationSchema = ( 23, n1, _ISWIR, @@ -2033,11 +2164,11 @@ (), ) -JSON_BLOBS_INPUT = (18, n1, _JBI, {_sSI: _aJBIO}, (_da,), ((1, 0),)) +JSON_BLOBS_INPUT: StaticSchema = (18, n1, _JBI, {_sSI: _aJBIO}, (_da,), ((1, 0),)) -JSON_BLOBS_OUTPUT = (18, n1, _JBO, {_sSI: _aJBIO}, (_da,), ((1, 0),)) +JSON_BLOBS_OUTPUT: StaticSchema = (18, n1, _JBO, {_sSI: _aJBIO}, (_da,), ((1, 0),)) -JSON_BLOBS = ( +JSON_BLOBS: StaticOperationSchema = ( 23, n1, _JB, @@ -2047,11 +2178,11 @@ (), ) -FOO_ENUM_MAP = (17, n0, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) +FOO_ENUM_MAP: StaticSchema = (17, n0, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -FOO_ENUM_SET = (16, n0, _FES, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_SET: StaticSchema = (16, n0, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -JSON_ENUMS_INPUT = ( +JSON_ENUMS_INPUT: StaticSchema = ( 18, n1, _JEI, @@ -2067,7 +2198,7 @@ ), ) -JSON_ENUMS_OUTPUT = ( +JSON_ENUMS_OUTPUT: StaticSchema = ( 18, n1, _JEO, @@ -2083,7 +2214,7 @@ ), ) -JSON_ENUMS = ( +JSON_ENUMS: StaticOperationSchema = ( 23, n1, _JE, @@ -2093,13 +2224,20 @@ (), ) -JSON_HEADER_STRING = (3, n1, _JHS, {_sT: _a}) +JSON_HEADER_STRING: StaticSchema = (3, n1, _JHS, {_sT: _a}) -INTEGER_ENUM_MAP = (17, n0, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) +INTEGER_ENUM_MAP: StaticSchema = ( + 17, + n0, + _IEM, + 0, + (_k, _v), + ((3, 0), (INTEGER_ENUM, 0)), +) -INTEGER_ENUM_SET = (16, n0, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_SET: StaticSchema = (16, n0, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) -JSON_INT_ENUMS_INPUT = ( +JSON_INT_ENUMS_INPUT: StaticSchema = ( 18, n1, _JIEI, @@ -2115,7 +2253,7 @@ ), ) -JSON_INT_ENUMS_OUTPUT = ( +JSON_INT_ENUMS_OUTPUT: StaticSchema = ( 18, n1, _JIEO, @@ -2131,7 +2269,7 @@ ), ) -JSON_INT_ENUMS = ( +JSON_INT_ENUMS: StaticOperationSchema = ( 23, n1, _JIE, @@ -2141,13 +2279,20 @@ (), ) -NESTED_STRING_LIST = (16, n0, _NSL, 0, (_m,), ((STRING_LIST, 0),)) +NESTED_STRING_LIST: StaticSchema = (16, n0, _NSL, 0, (_m,), ((STRING_LIST, 0),)) -STRUCTURE_LIST_MEMBER = (18, n1, _SLMt, 0, (_a_, _b_), ((3, {_sN: _v}), (3, {_sN: _o}))) +STRUCTURE_LIST_MEMBER: StaticSchema = ( + 18, + n1, + _SLMt, + 0, + (_a_, _b_), + ((3, {_sN: _v}), (3, {_sN: _o})), +) -STRUCTURE_LIST = (16, n1, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, 0),)) +STRUCTURE_LIST: StaticSchema = (16, n1, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, 0),)) -JSON_LISTS_INPUT = ( +JSON_LISTS_INPUT: StaticSchema = ( 18, n1, _JLI, @@ -2166,7 +2311,7 @@ ), ) -JSON_LISTS_OUTPUT = ( +JSON_LISTS_OUTPUT: StaticSchema = ( 18, n1, _JLO, @@ -2185,7 +2330,7 @@ ), ) -JSON_LISTS = ( +JSON_LISTS: StaticOperationSchema = ( 23, n1, _JL, @@ -2195,7 +2340,7 @@ (), ) -JSON_MAPS_INPUT = ( +JSON_MAPS_INPUT: StaticSchema = ( 18, n1, _JMI, @@ -2210,7 +2355,7 @@ ), ) -JSON_MAPS_OUTPUT = ( +JSON_MAPS_OUTPUT: StaticSchema = ( 18, n1, _JMO, @@ -2225,7 +2370,7 @@ ), ) -JSON_MAPS = ( +JSON_MAPS: StaticOperationSchema = ( 23, n1, _JM, @@ -2235,7 +2380,7 @@ (), ) -JSON_TIMESTAMPS_INPUT = ( +JSON_TIMESTAMPS_INPUT: StaticSchema = ( 18, n1, _JTI, @@ -2252,7 +2397,7 @@ ), ) -JSON_TIMESTAMPS_OUTPUT = ( +JSON_TIMESTAMPS_OUTPUT: StaticSchema = ( 18, n1, _JTO, @@ -2269,7 +2414,7 @@ ), ) -JSON_TIMESTAMPS = ( +JSON_TIMESTAMPS: StaticOperationSchema = ( 23, n1, _JT, @@ -2279,11 +2424,11 @@ (), ) -RENAMED_GREETING = (18, n2, _GS, 0, (_sa,), ((3, 0),)) +RENAMED_GREETING: StaticSchema = (18, n2, _GS, 0, (_sa,), ((3, 0),)) -NESTED_UNION = (19, n1, _NU, 0, (_sV,), ((3, 0),)) +NESTED_UNION: StaticSchema = (19, n1, _NU, 0, (_sV,), ((3, 0),)) -MY_UNION = ( +MY_UNION: StaticSchema = ( 19, n1, _MU, @@ -2304,11 +2449,25 @@ ), ) -JSON_UNIONS_INPUT = (18, n1, _JUI, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) +JSON_UNIONS_INPUT: StaticSchema = ( + 18, + n1, + _JUI, + {_sSI: _aUIO}, + (_co,), + ((MY_UNION, 0),), +) -JSON_UNIONS_OUTPUT = (18, n1, _JUO, {_sSI: _aUIO}, (_co,), ((MY_UNION, 0),)) +JSON_UNIONS_OUTPUT: StaticSchema = ( + 18, + n1, + _JUO, + {_sSI: _aUIO}, + (_co,), + ((MY_UNION, 0),), +) -JSON_UNIONS = ( +JSON_UNIONS: StaticOperationSchema = ( 23, n1, _JU, @@ -2318,13 +2477,20 @@ (), ) -JSON_VALUE = (3, n1, _JV, {_sT: _a}) +JSON_VALUE: StaticSchema = (3, n1, _JV, {_sT: _a}) -MALFORMED_ACCEPT_WITH_BODY_INPUT = (18, n1, _MAWBI, {_sSI: _sU}) +MALFORMED_ACCEPT_WITH_BODY_INPUT: StaticSchema = (18, n1, _MAWBI, {_sSI: _sU}) -MALFORMED_ACCEPT_WITH_BODY_OUTPUT = (18, n1, _MAWBO, {_sSI: _aGS}, (_hi,), ((3, 0),)) +MALFORMED_ACCEPT_WITH_BODY_OUTPUT: StaticSchema = ( + 18, + n1, + _MAWBO, + {_sSI: _aGS}, + (_hi,), + ((3, 0),), +) -MALFORMED_ACCEPT_WITH_BODY = ( +MALFORMED_ACCEPT_WITH_BODY: StaticOperationSchema = ( 23, n1, _MAWB, @@ -2334,11 +2500,23 @@ (), ) -MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT = (18, n1, _MAWGSI, {_sSI: _sU}) +MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT: StaticSchema = ( + 18, + n1, + _MAWGSI, + {_sSI: _sU}, +) -MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT = (18, n1, _MAWGSO, 0, (_p,), ((3, 16),)) +MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _MAWGSO, + 0, + (_p,), + ((3, 16),), +) -MALFORMED_ACCEPT_WITH_GENERIC_STRING = ( +MALFORMED_ACCEPT_WITH_GENERIC_STRING: StaticOperationSchema = ( 23, n1, _MAWGS, @@ -2352,13 +2530,20 @@ (), ) -MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT = (18, n1, _MAWPI, {_sSI: _sU}) +MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT: StaticSchema = (18, n1, _MAWPI, {_sSI: _sU}) -JPEG_BLOB = (1, n0, _JBp, {_sT: _im}) +JPEG_BLOB: StaticSchema = (1, n0, _JBp, {_sT: _im}) -MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT = (18, n1, _MAWPO, 0, (_p,), ((JPEG_BLOB, 16),)) +MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _MAWPO, + 0, + (_p,), + ((JPEG_BLOB, 16),), +) -MALFORMED_ACCEPT_WITH_PAYLOAD = ( +MALFORMED_ACCEPT_WITH_PAYLOAD: StaticOperationSchema = ( 23, n1, _MAWP, @@ -2368,11 +2553,11 @@ (), ) -MALFORMED_BLOB_INPUT = (18, n1, _MBI, 0, (_bl,), ((1, 0),)) +MALFORMED_BLOB_INPUT: StaticSchema = (18, n1, _MBI, 0, (_bl,), ((1, 0),)) -MALFORMED_BLOB_OUTPUT = (18, n1, _MBO, {_sSI: _sU}) +MALFORMED_BLOB_OUTPUT: StaticSchema = (18, n1, _MBO, {_sSI: _sU}) -MALFORMED_BLOB = ( +MALFORMED_BLOB: StaticOperationSchema = ( 23, n1, _MB, @@ -2382,7 +2567,7 @@ (), ) -MALFORMED_BOOLEAN_INPUT = ( +MALFORMED_BOOLEAN_INPUT: StaticSchema = ( 18, n1, _MBIa, @@ -2391,9 +2576,9 @@ ((2, 0), (2, 9), (2, {_sQ: _bIQ}), (2, {_sH: _bIH})), ) -MALFORMED_BOOLEAN_OUTPUT = (18, n1, _MBOa, {_sSI: _sU}) +MALFORMED_BOOLEAN_OUTPUT: StaticSchema = (18, n1, _MBOa, {_sSI: _sU}) -MALFORMED_BOOLEAN = ( +MALFORMED_BOOLEAN: StaticOperationSchema = ( 23, n1, _MBa, @@ -2407,7 +2592,7 @@ (), ) -MALFORMED_BYTE_INPUT = ( +MALFORMED_BYTE_INPUT: StaticSchema = ( 18, n1, _MBIal, @@ -2416,9 +2601,9 @@ ((5, 0), (5, 9), (5, {_sQ: _bIQy}), (5, {_sH: _bIHy})), ) -MALFORMED_BYTE_OUTPUT = (18, n1, _MBOal, {_sSI: _sU}) +MALFORMED_BYTE_OUTPUT: StaticSchema = (18, n1, _MBOal, {_sSI: _sU}) -MALFORMED_BYTE = ( +MALFORMED_BYTE: StaticOperationSchema = ( 23, n1, _MBal, @@ -2428,7 +2613,7 @@ (), ) -MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT = ( +MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT: StaticSchema = ( 18, n1, _MCTWBI, @@ -2437,9 +2622,9 @@ ((3, 0),), ) -MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT = (18, n1, _MCTWBO, {_sSI: _sU}) +MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT: StaticSchema = (18, n1, _MCTWBO, {_sSI: _sU}) -MALFORMED_CONTENT_TYPE_WITH_BODY = ( +MALFORMED_CONTENT_TYPE_WITH_BODY: StaticOperationSchema = ( 23, n1, _MCTWB, @@ -2449,7 +2634,7 @@ (), ) -MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT = ( +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT: StaticSchema = ( 18, n1, _MCTWGSI, @@ -2458,9 +2643,14 @@ ((3, 16),), ) -MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT = (18, n1, _MCTWGSO, {_sSI: _sU}) +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _MCTWGSO, + {_sSI: _sU}, +) -MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING = ( +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING: StaticOperationSchema = ( 23, n1, _MCTWGS, @@ -2474,11 +2664,21 @@ (), ) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT = (18, n1, _MCTWBIa, {_sSI: _sU}) +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT: StaticSchema = ( + 18, + n1, + _MCTWBIa, + {_sSI: _sU}, +) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT = (18, n1, _MCTWBOa, {_sSI: _sU}) +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT: StaticSchema = ( + 18, + n1, + _MCTWBOa, + {_sSI: _sU}, +) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY = ( +MALFORMED_CONTENT_TYPE_WITHOUT_BODY: StaticOperationSchema = ( 23, n1, _MCTWBa, @@ -2492,7 +2692,7 @@ (), ) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT = ( +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT: StaticSchema = ( 18, n1, _MCTWBEII, @@ -2501,14 +2701,14 @@ ((3, {_sH: _he}),), ) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT = ( +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT: StaticSchema = ( 18, n1, _MCTWBEIO, {_sSI: _sU}, ) -MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT = ( +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT: StaticOperationSchema = ( 23, n1, _MCTWBEI, @@ -2522,7 +2722,7 @@ (), ) -MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT = ( +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT: StaticSchema = ( 18, n1, _MCTWPI, @@ -2531,9 +2731,14 @@ ((JPEG_BLOB, 16),), ) -MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT = (18, n1, _MCTWPO, {_sSI: _sU}) +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _MCTWPO, + {_sSI: _sU}, +) -MALFORMED_CONTENT_TYPE_WITH_PAYLOAD = ( +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD: StaticOperationSchema = ( 23, n1, _MCTWP, @@ -2547,7 +2752,7 @@ (), ) -MALFORMED_DOUBLE_INPUT = ( +MALFORMED_DOUBLE_INPUT: StaticSchema = ( 18, n1, _MDI, @@ -2556,9 +2761,9 @@ ((10, 0), (10, 9), (10, {_sQ: _dIQ}), (10, {_sH: _dIH})), ) -MALFORMED_DOUBLE_OUTPUT = (18, n1, _MDO, {_sSI: _sU}) +MALFORMED_DOUBLE_OUTPUT: StaticSchema = (18, n1, _MDO, {_sSI: _sU}) -MALFORMED_DOUBLE = ( +MALFORMED_DOUBLE: StaticOperationSchema = ( 23, n1, _MD, @@ -2572,7 +2777,7 @@ (), ) -MALFORMED_FLOAT_INPUT = ( +MALFORMED_FLOAT_INPUT: StaticSchema = ( 18, n1, _MFI, @@ -2581,9 +2786,9 @@ ((9, 0), (9, 9), (9, {_sQ: _fIQ}), (9, {_sH: _fIH})), ) -MALFORMED_FLOAT_OUTPUT = (18, n1, _MFO, {_sSI: _sU}) +MALFORMED_FLOAT_OUTPUT: StaticSchema = (18, n1, _MFO, {_sSI: _sU}) -MALFORMED_FLOAT = ( +MALFORMED_FLOAT: StaticOperationSchema = ( 23, n1, _MF, @@ -2593,7 +2798,7 @@ (), ) -MALFORMED_INTEGER_INPUT = ( +MALFORMED_INTEGER_INPUT: StaticSchema = ( 18, n1, _MII, @@ -2602,9 +2807,9 @@ ((7, 0), (7, 9), (7, {_sQ: _iIQ}), (7, {_sH: _iIH})), ) -MALFORMED_INTEGER_OUTPUT = (18, n1, _MIO, {_sSI: _sU}) +MALFORMED_INTEGER_OUTPUT: StaticSchema = (18, n1, _MIO, {_sSI: _sU}) -MALFORMED_INTEGER = ( +MALFORMED_INTEGER: StaticOperationSchema = ( 23, n1, _MI, @@ -2618,13 +2823,13 @@ (), ) -SIMPLE_LIST = (16, n1, _SLi, 0, (_m,), ((3, 0),)) +SIMPLE_LIST: StaticSchema = (16, n1, _SLi, 0, (_m,), ((3, 0),)) -MALFORMED_LIST_INPUT = (18, n1, _MLI, 0, (_bLo,), ((SIMPLE_LIST, 0),)) +MALFORMED_LIST_INPUT: StaticSchema = (18, n1, _MLI, 0, (_bLo,), ((SIMPLE_LIST, 0),)) -MALFORMED_LIST_OUTPUT = (18, n1, _MLO, {_sSI: _sU}) +MALFORMED_LIST_OUTPUT: StaticSchema = (18, n1, _MLO, {_sSI: _sU}) -MALFORMED_LIST = ( +MALFORMED_LIST: StaticOperationSchema = ( 23, n1, _ML, @@ -2634,7 +2839,7 @@ (), ) -MALFORMED_LONG_INPUT = ( +MALFORMED_LONG_INPUT: StaticSchema = ( 18, n1, _MLIa, @@ -2643,9 +2848,9 @@ ((8, 0), (8, 9), (8, {_sQ: _lIQ}), (8, {_sH: _lIH})), ) -MALFORMED_LONG_OUTPUT = (18, n1, _MLOa, {_sSI: _sU}) +MALFORMED_LONG_OUTPUT: StaticSchema = (18, n1, _MLOa, {_sSI: _sU}) -MALFORMED_LONG = ( +MALFORMED_LONG: StaticOperationSchema = ( 23, n1, _MLa, @@ -2655,13 +2860,13 @@ (), ) -SIMPLE_MAP = (17, n1, _SMi, 0, (_k, _v), ((3, 0), (3, 0))) +SIMPLE_MAP: StaticSchema = (17, n1, _SMi, 0, (_k, _v), ((3, 0), (3, 0))) -MALFORMED_MAP_INPUT = (18, n1, _MMI, 0, (_bM,), ((SIMPLE_MAP, 0),)) +MALFORMED_MAP_INPUT: StaticSchema = (18, n1, _MMI, 0, (_bM,), ((SIMPLE_MAP, 0),)) -MALFORMED_MAP_OUTPUT = (18, n1, _MMO, {_sSI: _sU}) +MALFORMED_MAP_OUTPUT: StaticSchema = (18, n1, _MMO, {_sSI: _sU}) -MALFORMED_MAP = ( +MALFORMED_MAP: StaticOperationSchema = ( 23, n1, _MM, @@ -2671,11 +2876,18 @@ (), ) -MALFORMED_REQUEST_BODY_INPUT = (18, n1, _MRBI, 0, (_in, _fl), ((7, 0), (9, 0))) +MALFORMED_REQUEST_BODY_INPUT: StaticSchema = ( + 18, + n1, + _MRBI, + 0, + (_in, _fl), + ((7, 0), (9, 0)), +) -MALFORMED_REQUEST_BODY_OUTPUT = (18, n1, _MRBO, {_sSI: _sU}) +MALFORMED_REQUEST_BODY_OUTPUT: StaticSchema = (18, n1, _MRBO, {_sSI: _sU}) -MALFORMED_REQUEST_BODY = ( +MALFORMED_REQUEST_BODY: StaticOperationSchema = ( 23, n1, _MRB, @@ -2685,7 +2897,7 @@ (), ) -MALFORMED_SHORT_INPUT = ( +MALFORMED_SHORT_INPUT: StaticSchema = ( 18, n1, _MSI, @@ -2694,9 +2906,9 @@ ((6, 0), (6, 9), (6, {_sQ: _sIQ}), (6, {_sH: _sIH})), ) -MALFORMED_SHORT_OUTPUT = (18, n1, _MSO, {_sSI: _sU}) +MALFORMED_SHORT_OUTPUT: StaticSchema = (18, n1, _MSO, {_sSI: _sU}) -MALFORMED_SHORT = ( +MALFORMED_SHORT: StaticOperationSchema = ( 23, n1, _MS, @@ -2706,7 +2918,7 @@ (), ) -MALFORMED_STRING_INPUT = ( +MALFORMED_STRING_INPUT: StaticSchema = ( 18, n1, _MSIa, @@ -2715,9 +2927,9 @@ ((JSON_HEADER_STRING, {_sH: _amth}),), ) -MALFORMED_STRING_OUTPUT = (18, n1, _MSOa, {_sSI: _sU}) +MALFORMED_STRING_OUTPUT: StaticSchema = (18, n1, _MSOa, {_sSI: _sU}) -MALFORMED_STRING = ( +MALFORMED_STRING: StaticOperationSchema = ( 23, n1, _MSa, @@ -2727,7 +2939,7 @@ (), ) -MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT = ( +MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT: StaticSchema = ( 18, n1, _MTBDTI, @@ -2736,9 +2948,9 @@ ((4, {_sF: _dt, _smit: None}),), ) -MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT = (18, n1, _MTBDTO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT: StaticSchema = (18, n1, _MTBDTO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_BODY_DATE_TIME = ( +MALFORMED_TIMESTAMP_BODY_DATE_TIME: StaticOperationSchema = ( 23, n1, _MTBDT, @@ -2752,11 +2964,18 @@ (), ) -MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT = (18, n1, _MTBDI, 0, (_ti,), ((4, 1),)) +MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT: StaticSchema = ( + 18, + n1, + _MTBDI, + 0, + (_ti,), + ((4, 1),), +) -MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT = (18, n1, _MTBDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT: StaticSchema = (18, n1, _MTBDO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_BODY_DEFAULT = ( +MALFORMED_TIMESTAMP_BODY_DEFAULT: StaticOperationSchema = ( 23, n1, _MTBD, @@ -2766,7 +2985,7 @@ (), ) -MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT = ( +MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT: StaticSchema = ( 18, n1, _MTBHDI, @@ -2775,9 +2994,9 @@ ((4, {_sF: _hd, _smit: None}),), ) -MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT = (18, n1, _MTBHDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT: StaticSchema = (18, n1, _MTBHDO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_BODY_HTTP_DATE = ( +MALFORMED_TIMESTAMP_BODY_HTTP_DATE: StaticOperationSchema = ( 23, n1, _MTBHD, @@ -2791,7 +3010,7 @@ (), ) -MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT = ( +MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT: StaticSchema = ( 18, n1, _MTHDTI, @@ -2800,9 +3019,14 @@ ((4, {_sF: _dt, _sH: _ti, _smit: None}),), ) -MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT = (18, n1, _MTHDTO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT: StaticSchema = ( + 18, + n1, + _MTHDTO, + {_sSI: _sU}, +) -MALFORMED_TIMESTAMP_HEADER_DATE_TIME = ( +MALFORMED_TIMESTAMP_HEADER_DATE_TIME: StaticOperationSchema = ( 23, n1, _MTHDT, @@ -2816,7 +3040,7 @@ (), ) -MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT = ( +MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT: StaticSchema = ( 18, n1, _MTHDI, @@ -2825,9 +3049,9 @@ ((4, {_sH: _ti, _smit: None}),), ) -MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT = (18, n1, _MTHDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT: StaticSchema = (18, n1, _MTHDO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_HEADER_DEFAULT = ( +MALFORMED_TIMESTAMP_HEADER_DEFAULT: StaticOperationSchema = ( 23, n1, _MTHD, @@ -2841,7 +3065,7 @@ (), ) -MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT = ( +MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT: StaticSchema = ( 18, n1, _MTHEI, @@ -2850,9 +3074,9 @@ ((4, {_sF: _es, _sH: _ti, _smit: None}),), ) -MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT = (18, n1, _MTHEO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT: StaticSchema = (18, n1, _MTHEO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_HEADER_EPOCH = ( +MALFORMED_TIMESTAMP_HEADER_EPOCH: StaticOperationSchema = ( 23, n1, _MTHE, @@ -2862,11 +3086,18 @@ (), ) -MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT = (18, n1, _MTPDI, 0, (_ti,), ((4, 9),)) +MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT: StaticSchema = ( + 18, + n1, + _MTPDI, + 0, + (_ti,), + ((4, 9),), +) -MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT = (18, n1, _MTPDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT: StaticSchema = (18, n1, _MTPDO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_PATH_DEFAULT = ( +MALFORMED_TIMESTAMP_PATH_DEFAULT: StaticOperationSchema = ( 23, n1, _MTPD, @@ -2880,7 +3111,7 @@ (), ) -MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT = ( +MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT: StaticSchema = ( 18, n1, _MTPEI, @@ -2889,9 +3120,9 @@ ((4, {_sF: _es, _smit: None, _sL: None}),), ) -MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT = (18, n1, _MTPEO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT: StaticSchema = (18, n1, _MTPEO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_PATH_EPOCH = ( +MALFORMED_TIMESTAMP_PATH_EPOCH: StaticOperationSchema = ( 23, n1, _MTPE, @@ -2905,7 +3136,7 @@ (), ) -MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT = ( +MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT: StaticSchema = ( 18, n1, _MTPHDI, @@ -2914,9 +3145,9 @@ ((4, {_sF: _hd, _smit: None, _sL: None}),), ) -MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT = (18, n1, _MTPHDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT: StaticSchema = (18, n1, _MTPHDO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_PATH_HTTP_DATE = ( +MALFORMED_TIMESTAMP_PATH_HTTP_DATE: StaticOperationSchema = ( 23, n1, _MTPHD, @@ -2930,7 +3161,7 @@ (), ) -MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT = ( +MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT: StaticSchema = ( 18, n1, _MTQDI, @@ -2939,9 +3170,9 @@ ((4, {_sQ: _ti, _smit: None}),), ) -MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT = (18, n1, _MTQDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT: StaticSchema = (18, n1, _MTQDO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_QUERY_DEFAULT = ( +MALFORMED_TIMESTAMP_QUERY_DEFAULT: StaticOperationSchema = ( 23, n1, _MTQD, @@ -2955,7 +3186,7 @@ (), ) -MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT = ( +MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT: StaticSchema = ( 18, n1, _MTQEI, @@ -2964,9 +3195,9 @@ ((4, {_sF: _es, _sQ: _ti, _smit: None}),), ) -MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT = (18, n1, _MTQEO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT: StaticSchema = (18, n1, _MTQEO, {_sSI: _sU}) -MALFORMED_TIMESTAMP_QUERY_EPOCH = ( +MALFORMED_TIMESTAMP_QUERY_EPOCH: StaticOperationSchema = ( 23, n1, _MTQE, @@ -2976,7 +3207,7 @@ (), ) -MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT = ( +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT: StaticSchema = ( 18, n1, _MTQHDI, @@ -2985,9 +3216,14 @@ ((4, {_sF: _hd, _sQ: _ti, _smit: None}),), ) -MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT = (18, n1, _MTQHDO, {_sSI: _sU}) +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT: StaticSchema = ( + 18, + n1, + _MTQHDO, + {_sSI: _sU}, +) -MALFORMED_TIMESTAMP_QUERY_HTTP_DATE = ( +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE: StaticOperationSchema = ( 23, n1, _MTQHD, @@ -3001,13 +3237,13 @@ (), ) -SIMPLE_UNION = (19, n1, _SU, 0, (_in, _str), ((7, 0), (3, 0))) +SIMPLE_UNION: StaticSchema = (19, n1, _SU, 0, (_in, _str), ((7, 0), (3, 0))) -MALFORMED_UNION_INPUT = (18, n1, _MUI, 0, (_u,), ((SIMPLE_UNION, 0),)) +MALFORMED_UNION_INPUT: StaticSchema = (18, n1, _MUI, 0, (_u,), ((SIMPLE_UNION, 0),)) -MALFORMED_UNION_OUTPUT = (18, n1, _MUO, {_sSI: _sU}) +MALFORMED_UNION_OUTPUT: StaticSchema = (18, n1, _MUO, {_sSI: _sU}) -MALFORMED_UNION = ( +MALFORMED_UNION: StaticOperationSchema = ( 23, n1, _MUa, @@ -3017,11 +3253,25 @@ (), ) -MEDIA_TYPE_HEADER_INPUT = (18, n1, _MTHI, 0, (_j,), ((JSON_VALUE, {_sH: _XJ}),)) +MEDIA_TYPE_HEADER_INPUT: StaticSchema = ( + 18, + n1, + _MTHI, + 0, + (_j,), + ((JSON_VALUE, {_sH: _XJ}),), +) -MEDIA_TYPE_HEADER_OUTPUT = (18, n1, _MTHO, 0, (_j,), ((JSON_VALUE, {_sH: _XJ}),)) +MEDIA_TYPE_HEADER_OUTPUT: StaticSchema = ( + 18, + n1, + _MTHO, + 0, + (_j,), + ((JSON_VALUE, {_sH: _XJ}),), +) -MEDIA_TYPE_HEADER = ( +MEDIA_TYPE_HEADER: StaticOperationSchema = ( 23, n1, _MTH, @@ -3031,11 +3281,11 @@ (), ) -NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n1, _NIANOI, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_INPUT: StaticSchema = (18, n1, _NIANOI, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n1, _NIANOO, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_OUTPUT: StaticSchema = (18, n1, _NIANOO, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT = ( +NO_INPUT_AND_NO_OUTPUT: StaticOperationSchema = ( 23, n1, _NIANO, @@ -3045,11 +3295,11 @@ (), ) -NO_INPUT_AND_OUTPUT_INPUT = (18, n1, _NIAOI, {_sSI: _sU}) +NO_INPUT_AND_OUTPUT_INPUT: StaticSchema = (18, n1, _NIAOI, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_OUTPUT = (18, n1, _NIAOO, 0) +NO_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = (18, n1, _NIAOO, 0) -NO_INPUT_AND_OUTPUT = ( +NO_INPUT_AND_OUTPUT: StaticOperationSchema = ( 23, n1, _NIAO, @@ -3059,7 +3309,7 @@ (), ) -NULL_AND_EMPTY_HEADERS_CLIENT_INPUT = ( +NULL_AND_EMPTY_HEADERS_CLIENT_INPUT: StaticSchema = ( 18, n1, _NAEHCI, @@ -3068,7 +3318,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT = ( +NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT: StaticSchema = ( 18, n1, _NAEHCO, @@ -3077,7 +3327,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_CLIENT = ( +NULL_AND_EMPTY_HEADERS_CLIENT: StaticOperationSchema = ( 23, n1, _NAEHC, @@ -3087,7 +3337,7 @@ (), ) -NULL_AND_EMPTY_HEADERS_SERVER_INPUT = ( +NULL_AND_EMPTY_HEADERS_SERVER_INPUT: StaticSchema = ( 18, n1, _NAEHSI, @@ -3096,7 +3346,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT = ( +NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT: StaticSchema = ( 18, n1, _NAEHSO, @@ -3105,7 +3355,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_SERVER = ( +NULL_AND_EMPTY_HEADERS_SERVER: StaticOperationSchema = ( 23, n1, _NAEHS, @@ -3115,7 +3365,7 @@ (), ) -OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT = ( +OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT: StaticSchema = ( 18, n1, _ONSESI, @@ -3124,9 +3374,9 @@ ((3, {_sQ: _Nu}), (3, {_sQ: _Em})), ) -OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT = (18, n1, _ONSESO, {_sSI: _sU}) +OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT: StaticSchema = (18, n1, _ONSESO, {_sSI: _sU}) -OMITS_NULL_SERIALIZES_EMPTY_STRING = ( +OMITS_NULL_SERIALIZES_EMPTY_STRING: StaticOperationSchema = ( 23, n1, _ONSES, @@ -3136,7 +3386,7 @@ (), ) -OMITS_SERIALIZING_EMPTY_LISTS_INPUT = ( +OMITS_SERIALIZING_EMPTY_LISTS_INPUT: StaticSchema = ( 18, n1, _OSELI, @@ -3153,9 +3403,9 @@ ), ) -OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT = (18, n1, _OSELO, {_sSI: _sU}) +OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT: StaticSchema = (18, n1, _OSELO, {_sSI: _sU}) -OMITS_SERIALIZING_EMPTY_LISTS = ( +OMITS_SERIALIZING_EMPTY_LISTS: StaticOperationSchema = ( 23, n1, _OSEL, @@ -3165,7 +3415,7 @@ (), ) -OPERATION_WITH_DEFAULTS_INPUT = ( +OPERATION_WITH_DEFAULTS_INPUT: StaticSchema = ( 18, n1, _OWDI, @@ -3174,7 +3424,7 @@ ((DEFAULTS, 0), (CLIENT_OPTIONAL_DEFAULTS, 0), (3, {_sm: _hi}), (7, {_sm: 0})), ) -OPERATION_WITH_DEFAULTS_OUTPUT = ( +OPERATION_WITH_DEFAULTS_OUTPUT: StaticSchema = ( 18, n1, _OWDO, @@ -3241,7 +3491,7 @@ ), ) -OPERATION_WITH_DEFAULTS = ( +OPERATION_WITH_DEFAULTS: StaticOperationSchema = ( 23, n1, _OWD, @@ -3251,7 +3501,7 @@ (), ) -TOP_LEVEL = ( +TOP_LEVEL: StaticSchema = ( 18, n1, _TLo, @@ -3260,9 +3510,16 @@ ((DIALOG, 1), (DIALOG_LIST, {_sm: ()}), (DIALOG_MAP, {_sm: None})), ) -OPERATION_WITH_NESTED_STRUCTURE_INPUT = (18, n1, _OWNSI, 0, (_tLo,), ((TOP_LEVEL, 1),)) +OPERATION_WITH_NESTED_STRUCTURE_INPUT: StaticSchema = ( + 18, + n1, + _OWNSI, + 0, + (_tLo,), + ((TOP_LEVEL, 1),), +) -OPERATION_WITH_NESTED_STRUCTURE_OUTPUT = ( +OPERATION_WITH_NESTED_STRUCTURE_OUTPUT: StaticSchema = ( 18, n1, _OWNSO, @@ -3271,7 +3528,7 @@ ((DIALOG, 1), (DIALOG_LIST, {_sm: ()}), (DIALOG_MAP, {_sm: None})), ) -OPERATION_WITH_NESTED_STRUCTURE = ( +OPERATION_WITH_NESTED_STRUCTURE: StaticOperationSchema = ( 23, n1, _OWNS, @@ -3281,11 +3538,11 @@ (), ) -OUTPUT_STREAM_INPUT = (18, n1, _OSI, {_sSI: _sU}) +OUTPUT_STREAM_INPUT: StaticSchema = (18, n1, _OSI, {_sSI: _sU}) -OUTPUT_STREAM_OUTPUT = (18, n1, _OSO, 0, (_st,), ((EVENT_STREAM, 16),)) +OUTPUT_STREAM_OUTPUT: StaticSchema = (18, n1, _OSO, 0, (_st,), ((EVENT_STREAM, 16),)) -OUTPUT_STREAM = ( +OUTPUT_STREAM: StaticOperationSchema = ( 23, n1, _OS, @@ -3295,9 +3552,9 @@ (SERVICE_UNAVAILABLE_ERROR,), ) -OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT = (18, n1, _OSWIRI, {_sSI: _sU}) +OUTPUT_STREAM_WITH_INITIAL_RESPONSE_INPUT: StaticSchema = (18, n1, _OSWIRI, {_sSI: _sU}) -OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT = ( +OUTPUT_STREAM_WITH_INITIAL_RESPONSE_OUTPUT: StaticSchema = ( 18, n1, _OSWIRO, @@ -3306,7 +3563,7 @@ ((3, {_sH: _irm_, _smit: None}), (EVENT_STREAM, 16)), ) -OUTPUT_STREAM_WITH_INITIAL_RESPONSE = ( +OUTPUT_STREAM_WITH_INITIAL_RESPONSE: StaticOperationSchema = ( 23, n1, _OSWIR, @@ -3320,15 +3577,29 @@ (), ) -PAYLOAD_CONFIG = (18, n1, _PC, 0, (_da,), ((7, 0),)) +PAYLOAD_CONFIG: StaticSchema = (18, n1, _PC, 0, (_da,), ((7, 0),)) -PLAYER_ACTION = (19, n1, _PA, 0, (_q,), ((-1, 0),)) +PLAYER_ACTION: StaticSchema = (19, n1, _PA, 0, (_q,), ((-1, 0),)) -POST_PLAYER_ACTION_INPUT = (18, n1, _PPAI, 0, (_ac,), ((PLAYER_ACTION, 0),)) +POST_PLAYER_ACTION_INPUT: StaticSchema = ( + 18, + n1, + _PPAI, + 0, + (_ac,), + ((PLAYER_ACTION, 0),), +) -POST_PLAYER_ACTION_OUTPUT = (18, n1, _PPAO, 0, (_ac,), ((PLAYER_ACTION, 1),)) +POST_PLAYER_ACTION_OUTPUT: StaticSchema = ( + 18, + n1, + _PPAO, + 0, + (_ac,), + ((PLAYER_ACTION, 1),), +) -POST_PLAYER_ACTION = ( +POST_PLAYER_ACTION: StaticOperationSchema = ( 23, n1, _PPA, @@ -3338,7 +3609,7 @@ (), ) -UNION_WITH_JSON_NAME = ( +UNION_WITH_JSON_NAME: StaticSchema = ( 19, n1, _UWJN, @@ -3347,7 +3618,7 @@ ((3, {_sN: _FOO}), (3, 0), (3, {_sN: _baz})), ) -POST_UNION_WITH_JSON_NAME_INPUT = ( +POST_UNION_WITH_JSON_NAME_INPUT: StaticSchema = ( 18, n1, _PUWJNI, @@ -3356,7 +3627,7 @@ ((UNION_WITH_JSON_NAME, 0),), ) -POST_UNION_WITH_JSON_NAME_OUTPUT = ( +POST_UNION_WITH_JSON_NAME_OUTPUT: StaticSchema = ( 18, n1, _PUWJNO, @@ -3365,7 +3636,7 @@ ((UNION_WITH_JSON_NAME, 1),), ) -POST_UNION_WITH_JSON_NAME = ( +POST_UNION_WITH_JSON_NAME: StaticOperationSchema = ( 23, n1, _PUWJN, @@ -3375,7 +3646,7 @@ (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = ( +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( 18, n1, _PWCEI, @@ -3384,9 +3655,9 @@ ((3, {_sH: _CE_}), (3, 0)), ) -PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n1, _PWCEO, {_sSI: _sU}) +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = (18, n1, _PWCEO, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING = ( +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( 23, n1, _PWCE, @@ -3401,7 +3672,7 @@ (), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = ( +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT: StaticSchema = ( 18, n1, _QITAFI, @@ -3410,9 +3681,9 @@ ((3, {_sQ: _to, _sTm: None}),), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n1, _QITAFO, {_sSI: _sU}) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT: StaticSchema = (18, n1, _QITAFO, {_sSI: _sU}) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL: StaticOperationSchema = ( 23, n1, _QITAF, @@ -3422,7 +3693,7 @@ (), ) -QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT = ( +QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT: StaticSchema = ( 18, n1, _QPASLMI, @@ -3431,9 +3702,9 @@ ((3, {_sQ: _cor}), (STRING_LIST_MAP, 1024)), ) -QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT = (18, n1, _QPASLMO, {_sSI: _sU}) +QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT: StaticSchema = (18, n1, _QPASLMO, {_sSI: _sU}) -QUERY_PARAMS_AS_STRING_LIST_MAP = ( +QUERY_PARAMS_AS_STRING_LIST_MAP: StaticOperationSchema = ( 23, n1, _QPASLM, @@ -3443,7 +3714,7 @@ (), ) -QUERY_PRECEDENCE_INPUT = ( +QUERY_PRECEDENCE_INPUT: StaticSchema = ( 18, n1, _QPI, @@ -3452,9 +3723,9 @@ ((3, {_sQ: _ba}), (STRING_MAP, 1024)), ) -QUERY_PRECEDENCE_OUTPUT = (18, n1, _QPO, {_sSI: _sU}) +QUERY_PRECEDENCE_OUTPUT: StaticSchema = (18, n1, _QPO, {_sSI: _sU}) -QUERY_PRECEDENCE = ( +QUERY_PRECEDENCE: StaticOperationSchema = ( 23, n1, _QP, @@ -3464,11 +3735,11 @@ (), ) -RESPONSE_CODE_HTTP_FALLBACK_INPUT = (18, n1, _RCHFI, {_sSI: _aRCHFIO}) +RESPONSE_CODE_HTTP_FALLBACK_INPUT: StaticSchema = (18, n1, _RCHFI, {_sSI: _aRCHFIO}) -RESPONSE_CODE_HTTP_FALLBACK_OUTPUT = (18, n1, _RCHFO, {_sSI: _aRCHFIO}) +RESPONSE_CODE_HTTP_FALLBACK_OUTPUT: StaticSchema = (18, n1, _RCHFO, {_sSI: _aRCHFIO}) -RESPONSE_CODE_HTTP_FALLBACK = ( +RESPONSE_CODE_HTTP_FALLBACK: StaticOperationSchema = ( 23, n1, _RCHF, @@ -3482,11 +3753,11 @@ (), ) -RESPONSE_CODE_REQUIRED_INPUT = (18, n1, _RCRI, {_sSI: _sU}) +RESPONSE_CODE_REQUIRED_INPUT: StaticSchema = (18, n1, _RCRI, {_sSI: _sU}) -RESPONSE_CODE_REQUIRED_OUTPUT = (18, n1, _RCRO, 0, (_rC,), ((7, 129),)) +RESPONSE_CODE_REQUIRED_OUTPUT: StaticSchema = (18, n1, _RCRO, 0, (_rC,), ((7, 129),)) -RESPONSE_CODE_REQUIRED = ( +RESPONSE_CODE_REQUIRED: StaticOperationSchema = ( 23, n1, _RCR, @@ -3500,7 +3771,7 @@ (), ) -SIMPLE_SCALAR_PROPERTIES_INPUT = ( +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( 18, n1, _SSPI, @@ -3520,7 +3791,7 @@ ), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( 18, n1, _SSPO, @@ -3540,7 +3811,7 @@ ), ) -SIMPLE_SCALAR_PROPERTIES = ( +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( 23, n1, _SSP, @@ -3550,11 +3821,11 @@ (), ) -SPARSE_SHORT_LIST = (16, n0, _SSL, 64, (_m,), ((6, 0),)) +SPARSE_SHORT_LIST: StaticSchema = (16, n0, _SSL, 64, (_m,), ((6, 0),)) -SPARSE_STRING_LIST = (16, n0, _SSLp, 64, (_m,), ((3, 0),)) +SPARSE_STRING_LIST: StaticSchema = (16, n0, _SSLp, 64, (_m,), ((3, 0),)) -SPARSE_JSON_LISTS_INPUT = ( +SPARSE_JSON_LISTS_INPUT: StaticSchema = ( 18, n1, _SJLI, @@ -3563,7 +3834,7 @@ ((SPARSE_STRING_LIST, 0), (SPARSE_SHORT_LIST, 0)), ) -SPARSE_JSON_LISTS_OUTPUT = ( +SPARSE_JSON_LISTS_OUTPUT: StaticSchema = ( 18, n1, _SJLO, @@ -3572,7 +3843,7 @@ ((SPARSE_STRING_LIST, 0), (SPARSE_SHORT_LIST, 0)), ) -SPARSE_JSON_LISTS = ( +SPARSE_JSON_LISTS: StaticOperationSchema = ( 23, n1, _SJL, @@ -3582,17 +3853,24 @@ (), ) -SPARSE_BOOLEAN_MAP = (17, n1, _SBM, 64, (_k, _v), ((3, 0), (2, 0))) +SPARSE_BOOLEAN_MAP: StaticSchema = (17, n1, _SBM, 64, (_k, _v), ((3, 0), (2, 0))) -SPARSE_NUMBER_MAP = (17, n1, _SNM, 64, (_k, _v), ((3, 0), (7, 0))) +SPARSE_NUMBER_MAP: StaticSchema = (17, n1, _SNM, 64, (_k, _v), ((3, 0), (7, 0))) -SPARSE_SET_MAP = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (STRING_SET, 0))) +SPARSE_SET_MAP: StaticSchema = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (STRING_SET, 0))) -SPARSE_STRING_MAP = (17, n0, _SSMp, 64, (_k, _v), ((3, 0), (3, 0))) +SPARSE_STRING_MAP: StaticSchema = (17, n0, _SSMp, 64, (_k, _v), ((3, 0), (3, 0))) -SPARSE_STRUCT_MAP = (17, n1, _SSMpa, 64, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) +SPARSE_STRUCT_MAP: StaticSchema = ( + 17, + n1, + _SSMpa, + 64, + (_k, _v), + ((3, 0), (GREETING_STRUCT, 0)), +) -SPARSE_JSON_MAPS_INPUT = ( +SPARSE_JSON_MAPS_INPUT: StaticSchema = ( 18, n1, _SJMI, @@ -3607,7 +3885,7 @@ ), ) -SPARSE_JSON_MAPS_OUTPUT = ( +SPARSE_JSON_MAPS_OUTPUT: StaticSchema = ( 18, n1, _SJMO, @@ -3622,7 +3900,7 @@ ), ) -SPARSE_JSON_MAPS = ( +SPARSE_JSON_MAPS: StaticOperationSchema = ( 23, n1, _SJM, @@ -3632,9 +3910,9 @@ (), ) -STREAMING_BLOB = (1, n1, _SB, {_smith: None}) +STREAMING_BLOB: StaticSchema = (1, n1, _SB, {_smith: None}) -STREAMING_TRAITS_INPUT = ( +STREAMING_TRAITS_INPUT: StaticSchema = ( 18, n1, _STI, @@ -3643,7 +3921,7 @@ ((3, {_sH: _XF}), (STREAMING_BLOB, {_sm: _v_, _sPm: None})), ) -STREAMING_TRAITS_OUTPUT = ( +STREAMING_TRAITS_OUTPUT: StaticSchema = ( 18, n1, _STO, @@ -3652,7 +3930,7 @@ ((3, {_sH: _XF}), (STREAMING_BLOB, {_sm: _v_, _sPm: None})), ) -STREAMING_TRAITS = ( +STREAMING_TRAITS: StaticOperationSchema = ( 23, n1, _ST, @@ -3662,7 +3940,7 @@ (), ) -STREAMING_TRAITS_REQUIRE_LENGTH_INPUT = ( +STREAMING_TRAITS_REQUIRE_LENGTH_INPUT: StaticSchema = ( 18, n1, _STRLI, @@ -3671,9 +3949,9 @@ ((3, {_sH: _XF}), (FINITE_STREAMING_BLOB, {_sm: _v_, _sPm: None})), ) -STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT = (18, n1, _STRLO, {_sSI: _sU}) +STREAMING_TRAITS_REQUIRE_LENGTH_OUTPUT: StaticSchema = (18, n1, _STRLO, {_sSI: _sU}) -STREAMING_TRAITS_REQUIRE_LENGTH = ( +STREAMING_TRAITS_REQUIRE_LENGTH: StaticOperationSchema = ( 23, n1, _STRL, @@ -3683,9 +3961,9 @@ (), ) -STREAMING_TEXT_PLAIN_BLOB = (1, n1, _STPB, {_smith: None, _sT: _t}) +STREAMING_TEXT_PLAIN_BLOB: StaticSchema = (1, n1, _STPB, {_smith: None, _sT: _t}) -STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT = ( +STREAMING_TRAITS_WITH_MEDIA_TYPE_INPUT: StaticSchema = ( 18, n1, _STWMTI, @@ -3694,7 +3972,7 @@ ((3, {_sH: _XF}), (STREAMING_TEXT_PLAIN_BLOB, {_sm: _v_, _sPm: None})), ) -STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT = ( +STREAMING_TRAITS_WITH_MEDIA_TYPE_OUTPUT: StaticSchema = ( 18, n1, _STWMTO, @@ -3703,7 +3981,7 @@ ((3, {_sH: _XF}), (STREAMING_TEXT_PLAIN_BLOB, {_sm: _v_, _sPm: None})), ) -STREAMING_TRAITS_WITH_MEDIA_TYPE = ( +STREAMING_TRAITS_WITH_MEDIA_TYPE: StaticOperationSchema = ( 23, n1, _STWMT, @@ -3713,9 +3991,9 @@ (), ) -TEST_CONFIG = (18, n1, _TC, 0, (_tim,), ((7, 0),)) +TEST_CONFIG: StaticSchema = (18, n1, _TC, 0, (_tim,), ((7, 0),)) -TEST_BODY_STRUCTURE_INPUT = ( +TEST_BODY_STRUCTURE_INPUT: StaticSchema = ( 18, n1, _TBSI, @@ -3724,7 +4002,7 @@ ((3, {_sH: _xati}), (TEST_CONFIG, 0)), ) -TEST_BODY_STRUCTURE_OUTPUT = ( +TEST_BODY_STRUCTURE_OUTPUT: StaticSchema = ( 18, n1, _TBSO, @@ -3733,7 +4011,7 @@ ((3, {_sH: _xati}), (TEST_CONFIG, 0)), ) -TEST_BODY_STRUCTURE = ( +TEST_BODY_STRUCTURE: StaticOperationSchema = ( 23, n1, _TBS, @@ -3743,9 +4021,9 @@ (), ) -TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT = (18, n1, _TGNINPI, {_sSI: _sU}) +TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT: StaticSchema = (18, n1, _TGNINPI, {_sSI: _sU}) -TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT = ( +TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT: StaticSchema = ( 18, n1, _TGNINPO, @@ -3754,7 +4032,7 @@ ((3, {_sH: _XATI}),), ) -TEST_GET_NO_INPUT_NO_PAYLOAD = ( +TEST_GET_NO_INPUT_NO_PAYLOAD: StaticOperationSchema = ( 23, n1, _TGNINP, @@ -3764,7 +4042,7 @@ (), ) -TEST_GET_NO_PAYLOAD_INPUT = ( +TEST_GET_NO_PAYLOAD_INPUT: StaticSchema = ( 18, n1, _TGNPI, @@ -3773,7 +4051,7 @@ ((3, {_sH: _XATI}),), ) -TEST_GET_NO_PAYLOAD_OUTPUT = ( +TEST_GET_NO_PAYLOAD_OUTPUT: StaticSchema = ( 18, n1, _TGNPO, @@ -3782,7 +4060,7 @@ ((3, {_sH: _XATI}),), ) -TEST_GET_NO_PAYLOAD = ( +TEST_GET_NO_PAYLOAD: StaticOperationSchema = ( 23, n1, _TGNP, @@ -3792,7 +4070,7 @@ (), ) -TEST_PAYLOAD_BLOB_INPUT = ( +TEST_PAYLOAD_BLOB_INPUT: StaticSchema = ( 18, n1, _TPBI, @@ -3801,7 +4079,7 @@ ((3, {_sH: _CT}), (1, 16)), ) -TEST_PAYLOAD_BLOB_OUTPUT = ( +TEST_PAYLOAD_BLOB_OUTPUT: StaticSchema = ( 18, n1, _TPBO, @@ -3810,7 +4088,7 @@ ((3, {_sH: _CT}), (1, 16)), ) -TEST_PAYLOAD_BLOB = ( +TEST_PAYLOAD_BLOB: StaticOperationSchema = ( 23, n1, _TPBe, @@ -3820,7 +4098,7 @@ (), ) -TEST_PAYLOAD_STRUCTURE_INPUT = ( +TEST_PAYLOAD_STRUCTURE_INPUT: StaticSchema = ( 18, n1, _TPSI, @@ -3829,7 +4107,7 @@ ((3, {_sH: _xati}), (PAYLOAD_CONFIG, 16)), ) -TEST_PAYLOAD_STRUCTURE_OUTPUT = ( +TEST_PAYLOAD_STRUCTURE_OUTPUT: StaticSchema = ( 18, n1, _TPSO, @@ -3838,7 +4116,7 @@ ((3, {_sH: _xati}), (PAYLOAD_CONFIG, 16)), ) -TEST_PAYLOAD_STRUCTURE = ( +TEST_PAYLOAD_STRUCTURE: StaticOperationSchema = ( 23, n1, _TPS, @@ -3848,9 +4126,9 @@ (), ) -TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT = (18, n1, _TPNINPI, {_sSI: _sU}) +TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT: StaticSchema = (18, n1, _TPNINPI, {_sSI: _sU}) -TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT = ( +TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT: StaticSchema = ( 18, n1, _TPNINPO, @@ -3859,7 +4137,7 @@ ((3, {_sH: _XATI}),), ) -TEST_POST_NO_INPUT_NO_PAYLOAD = ( +TEST_POST_NO_INPUT_NO_PAYLOAD: StaticOperationSchema = ( 23, n1, _TPNINP, @@ -3869,7 +4147,7 @@ (), ) -TEST_POST_NO_PAYLOAD_INPUT = ( +TEST_POST_NO_PAYLOAD_INPUT: StaticSchema = ( 18, n1, _TPNPI, @@ -3878,7 +4156,7 @@ ((3, {_sH: _XATI}),), ) -TEST_POST_NO_PAYLOAD_OUTPUT = ( +TEST_POST_NO_PAYLOAD_OUTPUT: StaticSchema = ( 18, n1, _TPNPO, @@ -3887,7 +4165,7 @@ ((3, {_sH: _XATI}),), ) -TEST_POST_NO_PAYLOAD = ( +TEST_POST_NO_PAYLOAD: StaticOperationSchema = ( 23, n1, _TPNP, @@ -3897,7 +4175,7 @@ (), ) -TIMESTAMP_FORMAT_HEADERS_INPUT = ( +TIMESTAMP_FORMAT_HEADERS_INPUT: StaticSchema = ( 18, n1, _TFHI, @@ -3914,7 +4192,7 @@ ), ) -TIMESTAMP_FORMAT_HEADERS_OUTPUT = ( +TIMESTAMP_FORMAT_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _TFHO, @@ -3931,7 +4209,7 @@ ), ) -TIMESTAMP_FORMAT_HEADERS = ( +TIMESTAMP_FORMAT_HEADERS: StaticOperationSchema = ( 23, n1, _TFH, @@ -3941,11 +4219,11 @@ (), ) -UNIT_INPUT_AND_OUTPUT_INPUT = (18, n1, _UIAOI, {_sSI: _sU}) +UNIT_INPUT_AND_OUTPUT_INPUT: StaticSchema = (18, n1, _UIAOI, {_sSI: _sU}) -UNIT_INPUT_AND_OUTPUT_OUTPUT = (18, n1, _UIAOO, {_sSI: _sU}) +UNIT_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = (18, n1, _UIAOO, {_sSI: _sU}) -UNIT_INPUT_AND_OUTPUT = ( +UNIT_INPUT_AND_OUTPUT: StaticOperationSchema = ( 23, n1, _UIAO, @@ -3955,19 +4233,16 @@ (), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1: StaticSchema = ( 18, n1, _RSION, 0, (_fo, _ne), - ( - (3, 0), - (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] - ), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2: StaticSchema = ( 18, n1, _RSIONe, @@ -3976,7 +4251,7 @@ ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), ) -RECURSIVE_SHAPES_INPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT: StaticSchema = ( 18, n1, _RSI, @@ -3985,7 +4260,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_OUTPUT: StaticSchema = ( 18, n1, _RSO, @@ -3994,7 +4269,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES: StaticOperationSchema = ( 23, n1, _RS, @@ -4004,7 +4279,7 @@ (), ) -REST_JSON = ( +REST_JSON: StaticSchema = ( 21, n1, _RJ, @@ -4159,8 +4434,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -4172,8 +4447,8 @@ "endpoint": MappingProxyType( { "url": "https://restjson-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -4192,8 +4467,8 @@ "endpoint": MappingProxyType( { "url": "https://restjson.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -4205,8 +4480,8 @@ "endpoint": MappingProxyType( { "url": "https://restjson-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -4225,8 +4500,8 @@ "endpoint": MappingProxyType( { "url": "https://restjson.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -4245,8 +4520,8 @@ "endpoint": MappingProxyType( { "url": "https://restjson.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py b/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py index 340c4ff98..bd088dfa5 100644 --- a/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py +++ b/codegen-output/rest-xml-with-namespace/src/restxmlwithnamespace/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.restxml.xmlns" _NWN = "NestedWithNamespace" @@ -37,9 +39,16 @@ _sB = "smithy.rules#endpointBdd" _aw = "aws.api#service" -NESTED_WITH_NAMESPACE = (18, n0, _NWN, 0, (_aF,), ((3, {_sN: _xN, _sA: None}),)) +NESTED_WITH_NAMESPACE: StaticSchema = ( + 18, + n0, + _NWN, + 0, + (_aF,), + ((3, {_sN: _xN, _sA: None}),), +) -SIMPLE_SCALAR_PROPERTIES_INPUT = ( +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( 18, n0, _SSPI, @@ -63,7 +72,7 @@ ), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( 18, n0, _SSPO, @@ -87,7 +96,7 @@ ), ) -SIMPLE_SCALAR_PROPERTIES = ( +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( 23, n0, _SSP, @@ -97,7 +106,7 @@ (), ) -REST_XML_WITH_NAMESPACE = ( +REST_XML_WITH_NAMESPACE: StaticSchema = ( 21, n0, _RXWN, @@ -253,8 +262,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -266,8 +275,8 @@ "endpoint": MappingProxyType( { "url": "https://restxmlwithnamespace-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -286,8 +295,8 @@ "endpoint": MappingProxyType( { "url": "https://restxmlwithnamespace.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -299,8 +308,8 @@ "endpoint": MappingProxyType( { "url": "https://restxmlwithnamespace-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -319,8 +328,8 @@ "endpoint": MappingProxyType( { "url": "https://restxmlwithnamespace.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -339,8 +348,8 @@ "endpoint": MappingProxyType( { "url": "https://restxmlwithnamespace.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/rest-xml/src/restxml/_private/schemas.py b/codegen-output/rest-xml/src/restxml/_private/schemas.py index afd0518ac..06f91d077 100644 --- a/codegen-output/rest-xml/src/restxml/_private/schemas.py +++ b/codegen-output/rest-xml/src/restxml/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "aws.protocoltests.shared" _BL = "BooleanList" @@ -568,11 +570,11 @@ _sB = "smithy.rules#endpointBdd" _aws = "aws.api#service" -BOOLEAN_LIST = (16, n0, _BL, 0, (_m,), ((2, 0),)) +BOOLEAN_LIST: StaticSchema = (16, n0, _BL, 0, (_m,), ((2, 0),)) -DOUBLE_LIST = (16, n0, _DL, 0, (_m,), ((10, 0),)) +DOUBLE_LIST: StaticSchema = (16, n0, _DL, 0, (_m,), ((10, 0),)) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n0, _FE, @@ -581,25 +583,25 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -FOO_ENUM_LIST = (16, n0, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_LIST: StaticSchema = (16, n0, _FEL, 0, (_m,), ((FOO_ENUM, 0),)) -INTEGER_ENUM = (15, n0, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = (15, n0, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -INTEGER_ENUM_LIST = (16, n0, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_LIST: StaticSchema = (16, n0, _IEL, 0, (_m,), ((INTEGER_ENUM, 0),)) -INTEGER_LIST = (16, n0, _IL, 0, (_m,), ((7, 0),)) +INTEGER_LIST: StaticSchema = (16, n0, _IL, 0, (_m,), ((7, 0),)) -INTEGER_SET = (16, n0, _IS, 0, (_m,), ((7, 0),)) +INTEGER_SET: StaticSchema = (16, n0, _IS, 0, (_m,), ((7, 0),)) -STRING_MAP = (17, n0, _SM, 0, (_k, _v), ((3, 0), (3, 0))) +STRING_MAP: StaticSchema = (17, n0, _SM, 0, (_k, _v), ((3, 0), (3, 0))) -STRING_LIST = (16, n0, _SL, 0, (_m,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n0, _SL, 0, (_m,), ((3, 0),)) -STRING_SET = (16, n0, _SS, 0, (_m,), ((3, 0),)) +STRING_SET: StaticSchema = (16, n0, _SS, 0, (_m,), ((3, 0),)) -TIMESTAMP_LIST = (16, n0, _TL, 0, (_m,), ((4, 0),)) +TIMESTAMP_LIST: StaticSchema = (16, n0, _TL, 0, (_m,), ((4, 0),)) -ALL_QUERY_STRING_TYPES_INPUT = ( +ALL_QUERY_STRING_TYPES_INPUT: StaticSchema = ( 18, n1, _AQSTI, @@ -652,9 +654,9 @@ ), ) -ALL_QUERY_STRING_TYPES_OUTPUT = (18, n1, _AQSTO, {_sSI: _sU}) +ALL_QUERY_STRING_TYPES_OUTPUT: StaticSchema = (18, n1, _AQSTO, {_sSI: _sU}) -ALL_QUERY_STRING_TYPES = ( +ALL_QUERY_STRING_TYPES: StaticOperationSchema = ( 23, n1, _AQST, @@ -664,9 +666,9 @@ (), ) -PAYLOAD_WITH_XML_NAME = (18, n1, _PWXN, {_sN: _H}, (_n,), ((3, 0),)) +PAYLOAD_WITH_XML_NAME: StaticSchema = (18, n1, _PWXN, {_sN: _H}, (_n,), ((3, 0),)) -BODY_WITH_XML_NAME_INPUT = ( +BODY_WITH_XML_NAME_INPUT: StaticSchema = ( 18, n1, _BWXNI, @@ -675,7 +677,7 @@ ((PAYLOAD_WITH_XML_NAME, 0),), ) -BODY_WITH_XML_NAME_OUTPUT = ( +BODY_WITH_XML_NAME_OUTPUT: StaticSchema = ( 18, n1, _BWXNO, @@ -684,7 +686,7 @@ ((PAYLOAD_WITH_XML_NAME, 0),), ) -BODY_WITH_XML_NAME = ( +BODY_WITH_XML_NAME: StaticOperationSchema = ( 23, n1, _BWXN, @@ -694,9 +696,9 @@ (), ) -COMPLEX_NESTED_ERROR_DATA = (18, n1, _CNED, 0, (_Fo,), ((3, 0),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = (18, n1, _CNED, 0, (_Fo,), ((3, 0),)) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n1, _CE, @@ -705,7 +707,7 @@ ((3, {_sH: _XH}), (3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT = ( +CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT: StaticSchema = ( 18, n1, _CAVQSI, @@ -714,9 +716,9 @@ ((3, {_sQ: _b}), (3, {_sQ: _mS})), ) -CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT = (18, n1, _CAVQSO, {_sSI: _sU}) +CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT: StaticSchema = (18, n1, _CAVQSO, {_sSI: _sU}) -CONSTANT_AND_VARIABLE_QUERY_STRING = ( +CONSTANT_AND_VARIABLE_QUERY_STRING: StaticOperationSchema = ( 23, n1, _CAVQS, @@ -730,11 +732,11 @@ (), ) -CONSTANT_QUERY_STRING_INPUT = (18, n1, _CQSI, 0, (_h,), ((3, 9),)) +CONSTANT_QUERY_STRING_INPUT: StaticSchema = (18, n1, _CQSI, 0, (_h,), ((3, 9),)) -CONSTANT_QUERY_STRING_OUTPUT = (18, n1, _CQSO, {_sSI: _sU}) +CONSTANT_QUERY_STRING_OUTPUT: StaticSchema = (18, n1, _CQSO, {_sSI: _sU}) -CONSTANT_QUERY_STRING = ( +CONSTANT_QUERY_STRING: StaticOperationSchema = ( 23, n1, _CQS, @@ -748,11 +750,11 @@ (), ) -CONTENT_TYPE_PARAMETERS_INPUT = (18, n1, _CTPI, 0, (_v,), ((7, 0),)) +CONTENT_TYPE_PARAMETERS_INPUT: StaticSchema = (18, n1, _CTPI, 0, (_v,), ((7, 0),)) -CONTENT_TYPE_PARAMETERS_OUTPUT = (18, n1, _CTPO, 0) +CONTENT_TYPE_PARAMETERS_OUTPUT: StaticSchema = (18, n1, _CTPO, 0) -CONTENT_TYPE_PARAMETERS = ( +CONTENT_TYPE_PARAMETERS: StaticOperationSchema = ( 23, n1, _CTP, @@ -762,13 +764,13 @@ (), ) -DATETIME_OFFSETS_INPUT = (18, n1, _DOI, {_sSI: _sU}) +DATETIME_OFFSETS_INPUT: StaticSchema = (18, n1, _DOI, {_sSI: _sU}) -DATE_TIME = (4, n0, _DT, {_sF: _dt}) +DATE_TIME: StaticSchema = (4, n0, _DT, {_sF: _dt}) -DATETIME_OFFSETS_OUTPUT = (18, n1, _DOO, 0, (_d,), ((DATE_TIME, 0),)) +DATETIME_OFFSETS_OUTPUT: StaticSchema = (18, n1, _DOO, 0, (_d,), ((DATE_TIME, 0),)) -DATETIME_OFFSETS = ( +DATETIME_OFFSETS: StaticOperationSchema = ( 23, n1, _DO, @@ -778,11 +780,11 @@ (), ) -EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT = (18, n1, _EIAEOI, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT: StaticSchema = (18, n1, _EIAEOI, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT = (18, n1, _EIAEOO, 0) +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT: StaticSchema = (18, n1, _EIAEOO, 0) -EMPTY_INPUT_AND_EMPTY_OUTPUT = ( +EMPTY_INPUT_AND_EMPTY_OUTPUT: StaticOperationSchema = ( 23, n1, _EIAEO, @@ -792,11 +794,11 @@ (), ) -ENDPOINT_OPERATION_INPUT = (18, n1, _EOI, {_sSI: _sU}) +ENDPOINT_OPERATION_INPUT: StaticSchema = (18, n1, _EOI, {_sSI: _sU}) -ENDPOINT_OPERATION_OUTPUT = (18, n1, _EOO, {_sSI: _sU}) +ENDPOINT_OPERATION_OUTPUT: StaticSchema = (18, n1, _EOO, {_sSI: _sU}) -ENDPOINT_OPERATION = ( +ENDPOINT_OPERATION: StaticOperationSchema = ( 23, n1, _EO, @@ -809,7 +811,7 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT = ( +ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_INPUT: StaticSchema = ( 18, n1, _EWHLHOI, @@ -818,9 +820,14 @@ ((3, {_sH: _XAAI, _sLm: None, _smi: None}),), ) -ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT = (18, n1, _EWHLHOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION_OUTPUT: StaticSchema = ( + 18, + n1, + _EWHLHOO, + {_sSI: _sU}, +) -ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_HEADER_OPERATION: StaticOperationSchema = ( 23, n1, _EWHLHO, @@ -835,7 +842,7 @@ (), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( 18, n1, _EWHLOI, @@ -844,9 +851,9 @@ ((3, 257),), ) -ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT = (18, n1, _EWHLOO, {_sSI: _sU}) +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = (18, n1, _EWHLOO, {_sSI: _sU}) -ENDPOINT_WITH_HOST_LABEL_OPERATION = ( +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( 23, n1, _EWHLO, @@ -861,9 +868,9 @@ (), ) -FOO_ENUM_MAP = (17, n0, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) +FOO_ENUM_MAP: StaticSchema = (17, n0, _FEM, 0, (_k, _v), ((3, 0), (FOO_ENUM, 0))) -FLATTENED_XML_MAP_INPUT = ( +FLATTENED_XML_MAP_INPUT: StaticSchema = ( 18, n1, _FXMI, @@ -872,7 +879,7 @@ ((FOO_ENUM_MAP, {_sFm: None}),), ) -FLATTENED_XML_MAP_OUTPUT = ( +FLATTENED_XML_MAP_OUTPUT: StaticSchema = ( 18, n1, _FXMO, @@ -881,7 +888,7 @@ ((FOO_ENUM_MAP, {_sFm: None}),), ) -FLATTENED_XML_MAP = ( +FLATTENED_XML_MAP: StaticOperationSchema = ( 23, n1, _FXM, @@ -891,7 +898,7 @@ (), ) -FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP = ( +FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP: StaticSchema = ( 17, n1, _FXMWXNIOM, @@ -900,7 +907,7 @@ ((3, {_sN: _K}), (3, {_sN: _V})), ) -FLATTENED_XML_MAP_WITH_XML_NAME_INPUT = ( +FLATTENED_XML_MAP_WITH_XML_NAME_INPUT: StaticSchema = ( 18, n1, _FXMWXNI, @@ -909,7 +916,7 @@ ((FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP, {_sN: _KVP, _sFm: None}),), ) -FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT = ( +FLATTENED_XML_MAP_WITH_XML_NAME_OUTPUT: StaticSchema = ( 18, n1, _FXMWXNO, @@ -918,7 +925,7 @@ ((FLATTENED_XML_MAP_WITH_XML_NAME_INPUT_OUTPUT_MAP, {_sN: _KVP, _sFm: None}),), ) -FLATTENED_XML_MAP_WITH_XML_NAME = ( +FLATTENED_XML_MAP_WITH_XML_NAME: StaticOperationSchema = ( 23, n1, _FXMWXN, @@ -928,9 +935,14 @@ (), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT = (18, n1, _FXMWXNIl, {_sSI: _sU}) +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_INPUT: StaticSchema = ( + 18, + n1, + _FXMWXNIl, + {_sSI: _sU}, +) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP = ( +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT_MAP: StaticSchema = ( 17, n1, _FXMWXNOM, @@ -945,7 +957,7 @@ ), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT = ( +FLATTENED_XML_MAP_WITH_XML_NAMESPACE_OUTPUT: StaticSchema = ( 18, n1, _FXMWXNOl, @@ -963,7 +975,7 @@ ), ) -FLATTENED_XML_MAP_WITH_XML_NAMESPACE = ( +FLATTENED_XML_MAP_WITH_XML_NAMESPACE: StaticOperationSchema = ( 23, n1, _FXMWXNl, @@ -977,13 +989,13 @@ (), ) -FOO_PREFIX_HEADERS = (17, n1, _FPH, 0, (_k, _v), ((3, 0), (3, 0))) +FOO_PREFIX_HEADERS: StaticSchema = (17, n1, _FPH, 0, (_k, _v), ((3, 0), (3, 0))) -FRACTIONAL_SECONDS_INPUT = (18, n1, _FSI, {_sSI: _sU}) +FRACTIONAL_SECONDS_INPUT: StaticSchema = (18, n1, _FSI, {_sSI: _sU}) -FRACTIONAL_SECONDS_OUTPUT = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -FRACTIONAL_SECONDS = ( +FRACTIONAL_SECONDS: StaticOperationSchema = ( 23, n1, _FS, @@ -993,13 +1005,20 @@ (), ) -GREETING_WITH_ERRORS_INPUT = (18, n1, _GWEI, {_sSI: _sU}) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n1, _GWEI, {_sSI: _sU}) -GREETING_WITH_ERRORS_OUTPUT = (18, n1, _GWEO, 0, (_g,), ((3, {_sH: _XG}),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = ( + 18, + n1, + _GWEO, + 0, + (_g,), + ((3, {_sH: _XG}),), +) -INVALID_GREETING = (18, n1, _IG, {_sm: _c, _sE: 400}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n1, _IG, {_sm: _c, _sE: 400}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n1, _GWE, @@ -1009,7 +1028,7 @@ (INVALID_GREETING, COMPLEX_ERROR), ) -HTTP_EMPTY_PREFIX_HEADERS_INPUT = ( +HTTP_EMPTY_PREFIX_HEADERS_INPUT: StaticSchema = ( 18, n1, _HEPHI, @@ -1018,7 +1037,7 @@ ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -HTTP_EMPTY_PREFIX_HEADERS_OUTPUT = ( +HTTP_EMPTY_PREFIX_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _HEPHO, @@ -1027,7 +1046,7 @@ ((STRING_MAP, {_sPH: _v_}), (3, {_sH: _h})), ) -HTTP_EMPTY_PREFIX_HEADERS = ( +HTTP_EMPTY_PREFIX_HEADERS: StaticOperationSchema = ( 23, n1, _HEPH, @@ -1037,13 +1056,27 @@ (), ) -STRING_ENUM = (14, n1, _SE, 0, (_V,), ((-1, 0),)) +STRING_ENUM: StaticSchema = (14, n1, _SE, 0, (_V,), ((-1, 0),)) -HTTP_ENUM_PAYLOAD_INPUT = (18, n1, _HEPI, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) +HTTP_ENUM_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _HEPI, + {_sSI: _aEPI}, + (_p,), + ((STRING_ENUM, 16),), +) -HTTP_ENUM_PAYLOAD_OUTPUT = (18, n1, _HEPO, {_sSI: _aEPI}, (_p,), ((STRING_ENUM, 16),)) +HTTP_ENUM_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _HEPO, + {_sSI: _aEPI}, + (_p,), + ((STRING_ENUM, 16),), +) -HTTP_ENUM_PAYLOAD = ( +HTTP_ENUM_PAYLOAD: StaticOperationSchema = ( 23, n1, _HEP, @@ -1053,7 +1086,7 @@ (), ) -HTTP_PAYLOAD_TRAITS_INPUT = ( +HTTP_PAYLOAD_TRAITS_INPUT: StaticSchema = ( 18, n1, _HPTI, @@ -1062,7 +1095,7 @@ ((3, {_sH: _XF}), (1, 16)), ) -HTTP_PAYLOAD_TRAITS_OUTPUT = ( +HTTP_PAYLOAD_TRAITS_OUTPUT: StaticSchema = ( 18, n1, _HPTO, @@ -1071,7 +1104,7 @@ ((3, {_sH: _XF}), (1, 16)), ) -HTTP_PAYLOAD_TRAITS = ( +HTTP_PAYLOAD_TRAITS: StaticOperationSchema = ( 23, n1, _HPT, @@ -1081,9 +1114,9 @@ (), ) -TEXT_PLAIN_BLOB = (1, n0, _TPB, {_sT: _t}) +TEXT_PLAIN_BLOB: StaticSchema = (1, n0, _TPB, {_sT: _t}) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT = ( +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT: StaticSchema = ( 18, n1, _HPTWMTI, @@ -1092,7 +1125,7 @@ ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT = ( +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT: StaticSchema = ( 18, n1, _HPTWMTO, @@ -1101,7 +1134,7 @@ ((3, {_sH: _XF}), (TEXT_PLAIN_BLOB, 16)), ) -HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE = ( +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE: StaticOperationSchema = ( 23, n1, _HPTWMT, @@ -1115,7 +1148,7 @@ (), ) -HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT = ( +HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_INPUT: StaticSchema = ( 18, n1, _HPWMXNI, @@ -1124,7 +1157,7 @@ ((PAYLOAD_WITH_XML_NAME, {_sN: _Ho, _sP: None}),), ) -HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT = ( +HTTP_PAYLOAD_WITH_MEMBER_XML_NAME_OUTPUT: StaticSchema = ( 18, n1, _HPWMXNO, @@ -1133,7 +1166,7 @@ ((PAYLOAD_WITH_XML_NAME, {_sN: _Ho, _sP: None}),), ) -HTTP_PAYLOAD_WITH_MEMBER_XML_NAME = ( +HTTP_PAYLOAD_WITH_MEMBER_XML_NAME: StaticOperationSchema = ( 23, n1, _HPWMXN, @@ -1143,9 +1176,9 @@ (), ) -NESTED_PAYLOAD = (18, n1, _NP, 0, (_g, _n), ((3, 0), (3, 0))) +NESTED_PAYLOAD: StaticSchema = (18, n1, _NP, 0, (_g, _n), ((3, 0), (3, 0))) -HTTP_PAYLOAD_WITH_STRUCTURE_INPUT = ( +HTTP_PAYLOAD_WITH_STRUCTURE_INPUT: StaticSchema = ( 18, n1, _HPWSI, @@ -1154,7 +1187,7 @@ ((NESTED_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT = ( +HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT: StaticSchema = ( 18, n1, _HPWSO, @@ -1163,7 +1196,7 @@ ((NESTED_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_STRUCTURE = ( +HTTP_PAYLOAD_WITH_STRUCTURE: StaticOperationSchema = ( 23, n1, _HPWS, @@ -1173,9 +1206,9 @@ (), ) -UNION_PAYLOAD = (19, n1, _UP, 0, (_g,), ((3, 0),)) +UNION_PAYLOAD: StaticSchema = (19, n1, _UP, 0, (_g,), ((3, 0),)) -HTTP_PAYLOAD_WITH_UNION_INPUT = ( +HTTP_PAYLOAD_WITH_UNION_INPUT: StaticSchema = ( 18, n1, _HPWUI, @@ -1184,7 +1217,7 @@ ((UNION_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_UNION_OUTPUT = ( +HTTP_PAYLOAD_WITH_UNION_OUTPUT: StaticSchema = ( 18, n1, _HPWUO, @@ -1193,7 +1226,7 @@ ((UNION_PAYLOAD, 16),), ) -HTTP_PAYLOAD_WITH_UNION = ( +HTTP_PAYLOAD_WITH_UNION: StaticOperationSchema = ( 23, n1, _HPWU, @@ -1203,7 +1236,7 @@ (), ) -HTTP_PAYLOAD_WITH_XML_NAME_INPUT = ( +HTTP_PAYLOAD_WITH_XML_NAME_INPUT: StaticSchema = ( 18, n1, _HPWXNI, @@ -1212,7 +1245,7 @@ ((PAYLOAD_WITH_XML_NAME, 16),), ) -HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT = ( +HTTP_PAYLOAD_WITH_XML_NAME_OUTPUT: StaticSchema = ( 18, n1, _HPWXNO, @@ -1221,7 +1254,7 @@ ((PAYLOAD_WITH_XML_NAME, 16),), ) -HTTP_PAYLOAD_WITH_XML_NAME = ( +HTTP_PAYLOAD_WITH_XML_NAME: StaticOperationSchema = ( 23, n1, _HPWXN, @@ -1231,7 +1264,7 @@ (), ) -PAYLOAD_WITH_XML_NAMESPACE = ( +PAYLOAD_WITH_XML_NAMESPACE: StaticSchema = ( 18, n1, _PWXNa, @@ -1240,7 +1273,7 @@ ((3, 0),), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT = ( +HTTP_PAYLOAD_WITH_XML_NAMESPACE_INPUT: StaticSchema = ( 18, n1, _HPWXNIt, @@ -1249,7 +1282,7 @@ ((PAYLOAD_WITH_XML_NAMESPACE, 16),), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT = ( +HTTP_PAYLOAD_WITH_XML_NAMESPACE_OUTPUT: StaticSchema = ( 18, n1, _HPWXNOt, @@ -1258,7 +1291,7 @@ ((PAYLOAD_WITH_XML_NAMESPACE, 16),), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE = ( +HTTP_PAYLOAD_WITH_XML_NAMESPACE: StaticOperationSchema = ( 23, n1, _HPWXNt, @@ -1268,7 +1301,7 @@ (), ) -PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = ( +PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX: StaticSchema = ( 18, n1, _PWXNAP, @@ -1277,7 +1310,7 @@ ((3, 0),), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT = ( +HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_INPUT: StaticSchema = ( 18, n1, _HPWXNAPI, @@ -1286,7 +1319,7 @@ ((PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, 16),), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT = ( +HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX_OUTPUT: StaticSchema = ( 18, n1, _HPWXNAPO, @@ -1295,7 +1328,7 @@ ((PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX, 16),), ) -HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX = ( +HTTP_PAYLOAD_WITH_XML_NAMESPACE_AND_PREFIX: StaticOperationSchema = ( 23, n1, _HPWXNAP, @@ -1309,7 +1342,7 @@ (), ) -HTTP_PREFIX_HEADERS_INPUT = ( +HTTP_PREFIX_HEADERS_INPUT: StaticSchema = ( 18, n1, _HPHI, @@ -1318,7 +1351,7 @@ ((3, {_sH: _xf}), (FOO_PREFIX_HEADERS, {_sPH: _xf_})), ) -HTTP_PREFIX_HEADERS_OUTPUT = ( +HTTP_PREFIX_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _HPHO, @@ -1327,7 +1360,7 @@ ((3, {_sH: _xf}), (FOO_PREFIX_HEADERS, {_sPH: _xf_})), ) -HTTP_PREFIX_HEADERS = ( +HTTP_PREFIX_HEADERS: StaticOperationSchema = ( 23, n1, _HPH, @@ -1337,7 +1370,7 @@ (), ) -HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT = ( +HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT: StaticSchema = ( 18, n1, _HRWFLI, @@ -1346,9 +1379,9 @@ ((9, 9), (10, 9)), ) -HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT = (18, n1, _HRWFLO, {_sSI: _sU}) +HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT: StaticSchema = (18, n1, _HRWFLO, {_sSI: _sU}) -HTTP_REQUEST_WITH_FLOAT_LABELS = ( +HTTP_REQUEST_WITH_FLOAT_LABELS: StaticOperationSchema = ( 23, n1, _HRWFL, @@ -1362,7 +1395,7 @@ (), ) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT = ( +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT: StaticSchema = ( 18, n1, _HRWGLIPI, @@ -1371,9 +1404,14 @@ ((3, 9), (3, 9)), ) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT = (18, n1, _HRWGLIPO, {_sSI: _sU}) +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT: StaticSchema = ( + 18, + n1, + _HRWGLIPO, + {_sSI: _sU}, +) -HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH = ( +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH: StaticOperationSchema = ( 23, n1, _HRWGLIP, @@ -1390,7 +1428,7 @@ (), ) -HTTP_REQUEST_WITH_LABELS_INPUT = ( +HTTP_REQUEST_WITH_LABELS_INPUT: StaticSchema = ( 18, n1, _HRWLI, @@ -1399,9 +1437,9 @@ ((3, 9), (6, 9), (7, 9), (8, 9), (9, 9), (10, 9), (2, 9), (4, 9)), ) -HTTP_REQUEST_WITH_LABELS_OUTPUT = (18, n1, _HRWLO, {_sSI: _sU}) +HTTP_REQUEST_WITH_LABELS_OUTPUT: StaticSchema = (18, n1, _HRWLO, {_sSI: _sU}) -HTTP_REQUEST_WITH_LABELS = ( +HTTP_REQUEST_WITH_LABELS: StaticOperationSchema = ( 23, n1, _HRWL, @@ -1418,11 +1456,11 @@ (), ) -EPOCH_SECONDS = (4, n0, _ES, {_sF: _es}) +EPOCH_SECONDS: StaticSchema = (4, n0, _ES, {_sF: _es}) -HTTP_DATE = (4, n0, _HD, {_sF: _hd}) +HTTP_DATE: StaticSchema = (4, n0, _HD, {_sF: _hd}) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT = ( +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT: StaticSchema = ( 18, n1, _HRWLATFI, @@ -1439,9 +1477,14 @@ ), ) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT = (18, n1, _HRWLATFO, {_sSI: _sU}) +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT: StaticSchema = ( + 18, + n1, + _HRWLATFO, + {_sSI: _sU}, +) -HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT = ( +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT: StaticOperationSchema = ( 23, n1, _HRWLATF, @@ -1458,11 +1501,11 @@ (), ) -HTTP_RESPONSE_CODE_INPUT = (18, n1, _HRCI, {_sSI: _sU}) +HTTP_RESPONSE_CODE_INPUT: StaticSchema = (18, n1, _HRCI, {_sSI: _sU}) -HTTP_RESPONSE_CODE_OUTPUT = (18, n1, _HRCO, 0, (_St,), ((7, 128),)) +HTTP_RESPONSE_CODE_OUTPUT: StaticSchema = (18, n1, _HRCO, 0, (_St,), ((7, 128),)) -HTTP_RESPONSE_CODE = ( +HTTP_RESPONSE_CODE: StaticOperationSchema = ( 23, n1, _HRC, @@ -1472,11 +1515,25 @@ (), ) -HTTP_STRING_PAYLOAD_INPUT = (18, n1, _HSPI, {_sSI: _aSPI}, (_p,), ((3, 16),)) +HTTP_STRING_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _HSPI, + {_sSI: _aSPI}, + (_p,), + ((3, 16),), +) -HTTP_STRING_PAYLOAD_OUTPUT = (18, n1, _HSPO, {_sSI: _aSPI}, (_p,), ((3, 16),)) +HTTP_STRING_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _HSPO, + {_sSI: _aSPI}, + (_p,), + ((3, 16),), +) -HTTP_STRING_PAYLOAD = ( +HTTP_STRING_PAYLOAD: StaticOperationSchema = ( 23, n1, _HSP, @@ -1486,11 +1543,18 @@ (), ) -IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT = (18, n1, _IQPIRI, {_sSI: _sU}) +IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT: StaticSchema = (18, n1, _IQPIRI, {_sSI: _sU}) -IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT = (18, n1, _IQPIRO, 0, (_b,), ((3, {_sQ: _b}),)) +IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT: StaticSchema = ( + 18, + n1, + _IQPIRO, + 0, + (_b,), + ((3, {_sQ: _b}),), +) -IGNORE_QUERY_PARAMS_IN_RESPONSE = ( +IGNORE_QUERY_PARAMS_IN_RESPONSE: StaticOperationSchema = ( 23, n1, _IQPIR, @@ -1500,7 +1564,7 @@ (), ) -INPUT_AND_OUTPUT_WITH_HEADERS_INPUT = ( +INPUT_AND_OUTPUT_WITH_HEADERS_INPUT: StaticSchema = ( 18, n1, _IAOWHI, @@ -1543,7 +1607,7 @@ ), ) -INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT = ( +INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _IAOWHO, @@ -1586,7 +1650,7 @@ ), ) -INPUT_AND_OUTPUT_WITH_HEADERS = ( +INPUT_AND_OUTPUT_WITH_HEADERS: StaticOperationSchema = ( 23, n1, _IAOWH, @@ -1596,7 +1660,7 @@ (), ) -LIST_WITH_MEMBER_NAMESPACE = ( +LIST_WITH_MEMBER_NAMESPACE: StaticSchema = ( 16, n1, _LWMN, @@ -1605,7 +1669,7 @@ ((3, {_sNm: MappingProxyType({"uri": "https://xml-member.example.com"})}),), ) -LIST_WITH_NAMESPACE = ( +LIST_WITH_NAMESPACE: StaticSchema = ( 16, n1, _LWN, @@ -1614,9 +1678,9 @@ ((3, 0),), ) -NESTED_MAP = (17, n1, _NM, 0, (_k, _v), ((3, 0), (FOO_ENUM_MAP, 0))) +NESTED_MAP: StaticSchema = (17, n1, _NM, 0, (_k, _v), ((3, 0), (FOO_ENUM_MAP, 0))) -NESTED_XML_MAPS_INPUT = ( +NESTED_XML_MAPS_INPUT: StaticSchema = ( 18, n1, _NXMI, @@ -1625,7 +1689,7 @@ ((NESTED_MAP, 0), (NESTED_MAP, {_sFm: None})), ) -NESTED_XML_MAPS_OUTPUT = ( +NESTED_XML_MAPS_OUTPUT: StaticSchema = ( 18, n1, _NXMO, @@ -1634,7 +1698,7 @@ ((NESTED_MAP, 0), (NESTED_MAP, {_sFm: None})), ) -NESTED_XML_MAPS = ( +NESTED_XML_MAPS: StaticOperationSchema = ( 23, n1, _NXM, @@ -1644,7 +1708,7 @@ (), ) -NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP = ( +NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP: StaticSchema = ( 17, n1, _NXMWXNIM, @@ -1653,7 +1717,7 @@ ((3, {_sN: _IK}), (3, {_sN: _IV})), ) -NESTED_XML_MAP_WITH_XML_NAME_MAP = ( +NESTED_XML_MAP_WITH_XML_NAME_MAP: StaticSchema = ( 17, n1, _NXMWXNM, @@ -1662,7 +1726,7 @@ ((3, {_sN: _OK}), (NESTED_XML_MAP_WITH_XML_NAME_INNER_MAP, 0)), ) -NESTED_XML_MAP_WITH_XML_NAME_INPUT = ( +NESTED_XML_MAP_WITH_XML_NAME_INPUT: StaticSchema = ( 18, n1, _NXMWXNI, @@ -1671,7 +1735,7 @@ ((NESTED_XML_MAP_WITH_XML_NAME_MAP, 0),), ) -NESTED_XML_MAP_WITH_XML_NAME_OUTPUT = ( +NESTED_XML_MAP_WITH_XML_NAME_OUTPUT: StaticSchema = ( 18, n1, _NXMWXNO, @@ -1680,7 +1744,7 @@ ((NESTED_XML_MAP_WITH_XML_NAME_MAP, 0),), ) -NESTED_XML_MAP_WITH_XML_NAME = ( +NESTED_XML_MAP_WITH_XML_NAME: StaticOperationSchema = ( 23, n1, _NXMWXN, @@ -1690,11 +1754,11 @@ (), ) -NO_INPUT_AND_NO_OUTPUT_INPUT = (18, n1, _NIANOI, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_INPUT: StaticSchema = (18, n1, _NIANOI, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT_OUTPUT = (18, n1, _NIANOO, {_sSI: _sU}) +NO_INPUT_AND_NO_OUTPUT_OUTPUT: StaticSchema = (18, n1, _NIANOO, {_sSI: _sU}) -NO_INPUT_AND_NO_OUTPUT = ( +NO_INPUT_AND_NO_OUTPUT: StaticOperationSchema = ( 23, n1, _NIANO, @@ -1704,11 +1768,11 @@ (), ) -NO_INPUT_AND_OUTPUT_INPUT = (18, n1, _NIAOI, {_sSI: _sU}) +NO_INPUT_AND_OUTPUT_INPUT: StaticSchema = (18, n1, _NIAOI, {_sSI: _sU}) -NO_INPUT_AND_OUTPUT_OUTPUT = (18, n1, _NIAOO, 0) +NO_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = (18, n1, _NIAOO, 0) -NO_INPUT_AND_OUTPUT = ( +NO_INPUT_AND_OUTPUT: StaticOperationSchema = ( 23, n1, _NIAO, @@ -1718,7 +1782,7 @@ (), ) -NULL_AND_EMPTY_HEADERS_CLIENT_INPUT = ( +NULL_AND_EMPTY_HEADERS_CLIENT_INPUT: StaticSchema = ( 18, n1, _NAEHCI, @@ -1727,7 +1791,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT = ( +NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT: StaticSchema = ( 18, n1, _NAEHCO, @@ -1736,7 +1800,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_CLIENT = ( +NULL_AND_EMPTY_HEADERS_CLIENT: StaticOperationSchema = ( 23, n1, _NAEHC, @@ -1746,7 +1810,7 @@ (), ) -NULL_AND_EMPTY_HEADERS_SERVER_INPUT = ( +NULL_AND_EMPTY_HEADERS_SERVER_INPUT: StaticSchema = ( 18, n1, _NAEHSI, @@ -1755,7 +1819,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT = ( +NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT: StaticSchema = ( 18, n1, _NAEHSO, @@ -1764,7 +1828,7 @@ ((3, {_sH: _XA}), (3, {_sH: _XB____}), (STRING_LIST, {_sH: _XC})), ) -NULL_AND_EMPTY_HEADERS_SERVER = ( +NULL_AND_EMPTY_HEADERS_SERVER: StaticOperationSchema = ( 23, n1, _NAEHS, @@ -1774,7 +1838,7 @@ (), ) -OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT = ( +OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT: StaticSchema = ( 18, n1, _ONSESI, @@ -1783,9 +1847,9 @@ ((3, {_sQ: _Nu}), (3, {_sQ: _Em})), ) -OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT = (18, n1, _ONSESO, {_sSI: _sU}) +OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT: StaticSchema = (18, n1, _ONSESO, {_sSI: _sU}) -OMITS_NULL_SERIALIZES_EMPTY_STRING = ( +OMITS_NULL_SERIALIZES_EMPTY_STRING: StaticOperationSchema = ( 23, n1, _ONSES, @@ -1795,7 +1859,7 @@ (), ) -PUT_WITH_CONTENT_ENCODING_INPUT = ( +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( 18, n1, _PWCEI, @@ -1804,9 +1868,9 @@ ((3, {_sH: _CE_}), (3, 0)), ) -PUT_WITH_CONTENT_ENCODING_OUTPUT = (18, n1, _PWCEO, {_sSI: _sU}) +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = (18, n1, _PWCEO, {_sSI: _sU}) -PUT_WITH_CONTENT_ENCODING = ( +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( 23, n1, _PWCE, @@ -1821,7 +1885,7 @@ (), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT = ( +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT: StaticSchema = ( 18, n1, _QITAFI, @@ -1830,9 +1894,9 @@ ((3, {_sQ: _to, _sTm: None}),), ) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT = (18, n1, _QITAFO, {_sSI: _sU}) +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT: StaticSchema = (18, n1, _QITAFO, {_sSI: _sU}) -QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL = ( +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL: StaticOperationSchema = ( 23, n1, _QITAF, @@ -1842,9 +1906,9 @@ (), ) -STRING_LIST_MAP = (17, n0, _SLM, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) +STRING_LIST_MAP: StaticSchema = (17, n0, _SLM, 0, (_k, _v), ((3, 0), (STRING_LIST, 0))) -QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT = ( +QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT: StaticSchema = ( 18, n1, _QPASLMI, @@ -1853,9 +1917,9 @@ ((3, {_sQ: _co}), (STRING_LIST_MAP, 1024)), ) -QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT = (18, n1, _QPASLMO, {_sSI: _sU}) +QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT: StaticSchema = (18, n1, _QPASLMO, {_sSI: _sU}) -QUERY_PARAMS_AS_STRING_LIST_MAP = ( +QUERY_PARAMS_AS_STRING_LIST_MAP: StaticOperationSchema = ( 23, n1, _QPASLM, @@ -1865,7 +1929,7 @@ (), ) -QUERY_PRECEDENCE_INPUT = ( +QUERY_PRECEDENCE_INPUT: StaticSchema = ( 18, n1, _QPI, @@ -1874,9 +1938,9 @@ ((3, {_sQ: _ba}), (STRING_MAP, 1024)), ) -QUERY_PRECEDENCE_OUTPUT = (18, n1, _QPO, {_sSI: _sU}) +QUERY_PRECEDENCE_OUTPUT: StaticSchema = (18, n1, _QPO, {_sSI: _sU}) -QUERY_PRECEDENCE = ( +QUERY_PRECEDENCE: StaticOperationSchema = ( 23, n1, _QP, @@ -1886,9 +1950,9 @@ (), ) -RENAMED_LIST_MEMBERS = (16, n1, _RLM, 0, (_m,), ((3, {_sN: _it}),)) +RENAMED_LIST_MEMBERS: StaticSchema = (16, n1, _RLM, 0, (_m,), ((3, {_sN: _it}),)) -SIMPLE_SCALAR_PROPERTIES_INPUT = ( +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( 18, n1, _SSPI, @@ -1908,7 +1972,7 @@ ), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( 18, n1, _SSPO, @@ -1928,7 +1992,7 @@ ), ) -SIMPLE_SCALAR_PROPERTIES = ( +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( 23, n1, _SSP, @@ -1938,7 +2002,7 @@ (), ) -TIMESTAMP_FORMAT_HEADERS_INPUT = ( +TIMESTAMP_FORMAT_HEADERS_INPUT: StaticSchema = ( 18, n1, _TFHI, @@ -1955,7 +2019,7 @@ ), ) -TIMESTAMP_FORMAT_HEADERS_OUTPUT = ( +TIMESTAMP_FORMAT_HEADERS_OUTPUT: StaticSchema = ( 18, n1, _TFHO, @@ -1972,7 +2036,7 @@ ), ) -TIMESTAMP_FORMAT_HEADERS = ( +TIMESTAMP_FORMAT_HEADERS: StaticOperationSchema = ( 23, n1, _TFH, @@ -1982,7 +2046,7 @@ (), ) -XML_ATTRIBUTES_INPUT = ( +XML_ATTRIBUTES_INPUT: StaticSchema = ( 18, n1, _XAI, @@ -1991,7 +2055,7 @@ ((3, 0), (3, {_sN: _te, _sA: None})), ) -XML_ATTRIBUTES_OUTPUT = ( +XML_ATTRIBUTES_OUTPUT: StaticSchema = ( 18, n1, _XAO, @@ -2000,7 +2064,7 @@ ((3, 0), (3, {_sN: _te, _sA: None})), ) -XML_ATTRIBUTES = ( +XML_ATTRIBUTES: StaticOperationSchema = ( 23, n1, _XAm, @@ -2010,7 +2074,7 @@ (), ) -XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST = ( +XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST: StaticSchema = ( 18, n1, _XAIMPR, @@ -2019,7 +2083,7 @@ ((3, 0), (3, {_sN: _te, _sA: None}), (3, 0)), ) -XML_ATTRIBUTES_IN_MIDDLE_INPUT = ( +XML_ATTRIBUTES_IN_MIDDLE_INPUT: StaticSchema = ( 18, n1, _XAIMI, @@ -2028,7 +2092,7 @@ ((XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_REQUEST, 16),), ) -XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE = ( +XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE: StaticSchema = ( 18, n1, _XAIMPRm, @@ -2037,7 +2101,7 @@ ((3, 0), (3, {_sN: _te, _sA: None}), (3, 0)), ) -XML_ATTRIBUTES_IN_MIDDLE_OUTPUT = ( +XML_ATTRIBUTES_IN_MIDDLE_OUTPUT: StaticSchema = ( 18, n1, _XAIMO, @@ -2046,7 +2110,7 @@ ((XML_ATTRIBUTES_IN_MIDDLE_PAYLOAD_RESPONSE, 16),), ) -XML_ATTRIBUTES_IN_MIDDLE = ( +XML_ATTRIBUTES_IN_MIDDLE: StaticOperationSchema = ( 23, n1, _XAIM, @@ -2056,7 +2120,7 @@ (), ) -XML_ATTRIBUTES_PAYLOAD_REQUEST = ( +XML_ATTRIBUTES_PAYLOAD_REQUEST: StaticSchema = ( 18, n1, _XAPR, @@ -2065,7 +2129,7 @@ ((3, 0), (3, {_sN: _te, _sA: None})), ) -XML_ATTRIBUTES_ON_PAYLOAD_INPUT = ( +XML_ATTRIBUTES_ON_PAYLOAD_INPUT: StaticSchema = ( 18, n1, _XAOPI, @@ -2074,7 +2138,7 @@ ((XML_ATTRIBUTES_PAYLOAD_REQUEST, 16),), ) -XML_ATTRIBUTES_PAYLOAD_RESPONSE = ( +XML_ATTRIBUTES_PAYLOAD_RESPONSE: StaticSchema = ( 18, n1, _XAPRm, @@ -2083,7 +2147,7 @@ ((3, 0), (3, {_sN: _te, _sA: None})), ) -XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT = ( +XML_ATTRIBUTES_ON_PAYLOAD_OUTPUT: StaticSchema = ( 18, n1, _XAOPO, @@ -2092,7 +2156,7 @@ ((XML_ATTRIBUTES_PAYLOAD_RESPONSE, 16),), ) -XML_ATTRIBUTES_ON_PAYLOAD = ( +XML_ATTRIBUTES_ON_PAYLOAD: StaticOperationSchema = ( 23, n1, _XAOP, @@ -2102,11 +2166,11 @@ (), ) -XML_BLOBS_INPUT = (18, n1, _XBI, {_sSI: _aXBR}, (_da,), ((1, 0),)) +XML_BLOBS_INPUT: StaticSchema = (18, n1, _XBI, {_sSI: _aXBR}, (_da,), ((1, 0),)) -XML_BLOBS_OUTPUT = (18, n1, _XBO, {_sSI: _aXBRw}, (_da,), ((1, 0),)) +XML_BLOBS_OUTPUT: StaticSchema = (18, n1, _XBO, {_sSI: _aXBRw}, (_da,), ((1, 0),)) -XML_BLOBS = ( +XML_BLOBS: StaticOperationSchema = ( 23, n1, _XBm, @@ -2116,11 +2180,18 @@ (), ) -XML_EMPTY_BLOBS_INPUT = (18, n1, _XEBI, {_sSI: _aXEBR}, (_da,), ((1, 0),)) +XML_EMPTY_BLOBS_INPUT: StaticSchema = (18, n1, _XEBI, {_sSI: _aXEBR}, (_da,), ((1, 0),)) -XML_EMPTY_BLOBS_OUTPUT = (18, n1, _XEBO, {_sSI: _aXEBRw}, (_da,), ((1, 0),)) +XML_EMPTY_BLOBS_OUTPUT: StaticSchema = ( + 18, + n1, + _XEBO, + {_sSI: _aXEBRw}, + (_da,), + ((1, 0),), +) -XML_EMPTY_BLOBS = ( +XML_EMPTY_BLOBS: StaticOperationSchema = ( 23, n1, _XEB, @@ -2130,13 +2201,27 @@ (), ) -STRUCTURE_LIST_MEMBER = (18, n1, _SLMt, 0, (_a, _b_), ((3, {_sN: _v}), (3, {_sN: _o}))) +STRUCTURE_LIST_MEMBER: StaticSchema = ( + 18, + n1, + _SLMt, + 0, + (_a, _b_), + ((3, {_sN: _v}), (3, {_sN: _o})), +) -STRUCTURE_LIST = (16, n1, _SLt, 0, (_m,), ((STRUCTURE_LIST_MEMBER, {_sN: _it}),)) +STRUCTURE_LIST: StaticSchema = ( + 16, + n1, + _SLt, + 0, + (_m,), + ((STRUCTURE_LIST_MEMBER, {_sN: _it}),), +) -NESTED_STRING_LIST = (16, n0, _NSL, 0, (_m,), ((STRING_LIST, 0),)) +NESTED_STRING_LIST: StaticSchema = (16, n0, _NSL, 0, (_m,), ((STRING_LIST, 0),)) -XML_EMPTY_LISTS_INPUT = ( +XML_EMPTY_LISTS_INPUT: StaticSchema = ( 18, n1, _XELI, @@ -2177,7 +2262,7 @@ ), ) -XML_EMPTY_LISTS_OUTPUT = ( +XML_EMPTY_LISTS_OUTPUT: StaticSchema = ( 18, n1, _XELO, @@ -2218,7 +2303,7 @@ ), ) -XML_EMPTY_LISTS = ( +XML_EMPTY_LISTS: StaticOperationSchema = ( 23, n1, _XEL, @@ -2228,9 +2313,9 @@ (), ) -GREETING_STRUCT = (18, n0, _GS, 0, (_hi,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n0, _GS, 0, (_hi,), ((3, 0),)) -XML_MAPS_INPUT_OUTPUT_MAP = ( +XML_MAPS_INPUT_OUTPUT_MAP: StaticSchema = ( 17, n1, _XMIOM, @@ -2239,7 +2324,7 @@ ((3, 0), (GREETING_STRUCT, 0)), ) -XML_EMPTY_MAPS_INPUT = ( +XML_EMPTY_MAPS_INPUT: StaticSchema = ( 18, n1, _XEMI, @@ -2248,7 +2333,7 @@ ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), ) -XML_EMPTY_MAPS_OUTPUT = ( +XML_EMPTY_MAPS_OUTPUT: StaticSchema = ( 18, n1, _XEMO, @@ -2257,7 +2342,7 @@ ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), ) -XML_EMPTY_MAPS = ( +XML_EMPTY_MAPS: StaticOperationSchema = ( 23, n1, _XEM, @@ -2267,11 +2352,25 @@ (), ) -XML_EMPTY_STRINGS_INPUT = (18, n1, _XESI, {_sSI: _aXESR}, (_eS,), ((3, 0),)) +XML_EMPTY_STRINGS_INPUT: StaticSchema = ( + 18, + n1, + _XESI, + {_sSI: _aXESR}, + (_eS,), + ((3, 0),), +) -XML_EMPTY_STRINGS_OUTPUT = (18, n1, _XESO, {_sSI: _aXESRw}, (_eS,), ((3, 0),)) +XML_EMPTY_STRINGS_OUTPUT: StaticSchema = ( + 18, + n1, + _XESO, + {_sSI: _aXESRw}, + (_eS,), + ((3, 0),), +) -XML_EMPTY_STRINGS = ( +XML_EMPTY_STRINGS: StaticOperationSchema = ( 23, n1, _XES, @@ -2281,9 +2380,9 @@ (), ) -FOO_ENUM_SET = (16, n0, _FES, 0, (_m,), ((FOO_ENUM, 0),)) +FOO_ENUM_SET: StaticSchema = (16, n0, _FES, 0, (_m,), ((FOO_ENUM, 0),)) -XML_ENUMS_INPUT = ( +XML_ENUMS_INPUT: StaticSchema = ( 18, n1, _XEI, @@ -2299,7 +2398,7 @@ ), ) -XML_ENUMS_OUTPUT = ( +XML_ENUMS_OUTPUT: StaticSchema = ( 18, n1, _XEO, @@ -2315,7 +2414,7 @@ ), ) -XML_ENUMS = ( +XML_ENUMS: StaticOperationSchema = ( 23, n1, _XEm, @@ -2325,11 +2424,18 @@ (), ) -INTEGER_ENUM_MAP = (17, n0, _IEM, 0, (_k, _v), ((3, 0), (INTEGER_ENUM, 0))) +INTEGER_ENUM_MAP: StaticSchema = ( + 17, + n0, + _IEM, + 0, + (_k, _v), + ((3, 0), (INTEGER_ENUM, 0)), +) -INTEGER_ENUM_SET = (16, n0, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_SET: StaticSchema = (16, n0, _IES, 0, (_m,), ((INTEGER_ENUM, 0),)) -XML_INT_ENUMS_INPUT = ( +XML_INT_ENUMS_INPUT: StaticSchema = ( 18, n1, _XIEI, @@ -2345,7 +2451,7 @@ ), ) -XML_INT_ENUMS_OUTPUT = ( +XML_INT_ENUMS_OUTPUT: StaticSchema = ( 18, n1, _XIEO, @@ -2361,7 +2467,7 @@ ), ) -XML_INT_ENUMS = ( +XML_INT_ENUMS: StaticOperationSchema = ( 23, n1, _XIE, @@ -2371,7 +2477,7 @@ (), ) -XML_LISTS_INPUT = ( +XML_LISTS_INPUT: StaticSchema = ( 18, n1, _XLI, @@ -2412,7 +2518,7 @@ ), ) -XML_LISTS_OUTPUT = ( +XML_LISTS_OUTPUT: StaticSchema = ( 18, n1, _XLO, @@ -2453,7 +2559,7 @@ ), ) -XML_LISTS = ( +XML_LISTS: StaticOperationSchema = ( 23, n1, _XLm, @@ -2463,7 +2569,7 @@ (), ) -XML_MAPS_INPUT = ( +XML_MAPS_INPUT: StaticSchema = ( 18, n1, _XMI, @@ -2472,7 +2578,7 @@ ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), ) -XML_MAPS_OUTPUT = ( +XML_MAPS_OUTPUT: StaticSchema = ( 18, n1, _XMO, @@ -2481,7 +2587,7 @@ ((XML_MAPS_INPUT_OUTPUT_MAP, 0),), ) -XML_MAPS = ( +XML_MAPS: StaticOperationSchema = ( 23, n1, _XM, @@ -2491,7 +2597,7 @@ (), ) -XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP = ( +XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP: StaticSchema = ( 17, n1, _XMXNIOM, @@ -2500,7 +2606,7 @@ ((3, {_sN: _At}), (GREETING_STRUCT, {_sN: _Se})), ) -XML_MAPS_XML_NAME_INPUT = ( +XML_MAPS_XML_NAME_INPUT: StaticSchema = ( 18, n1, _XMXNI, @@ -2509,7 +2615,7 @@ ((XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP, 0),), ) -XML_MAPS_XML_NAME_OUTPUT = ( +XML_MAPS_XML_NAME_OUTPUT: StaticSchema = ( 18, n1, _XMXNO, @@ -2518,7 +2624,7 @@ ((XML_MAPS_XML_NAME_INPUT_OUTPUT_MAP, 0),), ) -XML_MAPS_XML_NAME = ( +XML_MAPS_XML_NAME: StaticOperationSchema = ( 23, n1, _XMXN, @@ -2528,7 +2634,7 @@ (), ) -XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP = ( +XML_MAP_WITH_XML_NAMESPACE_INPUT_OUTPUT_MAP: StaticSchema = ( 17, n1, _XMWXNIOM, @@ -2543,7 +2649,7 @@ ), ) -XML_MAP_WITH_XML_NAMESPACE_INPUT = ( +XML_MAP_WITH_XML_NAMESPACE_INPUT: StaticSchema = ( 18, n1, _XMWXNI, @@ -2560,7 +2666,7 @@ ), ) -XML_MAP_WITH_XML_NAMESPACE_OUTPUT = ( +XML_MAP_WITH_XML_NAMESPACE_OUTPUT: StaticSchema = ( 18, n1, _XMWXNO, @@ -2577,7 +2683,7 @@ ), ) -XML_MAP_WITH_XML_NAMESPACE = ( +XML_MAP_WITH_XML_NAMESPACE: StaticOperationSchema = ( 23, n1, _XMWXN, @@ -2587,7 +2693,7 @@ (), ) -XML_NAMESPACED_LIST = ( +XML_NAMESPACED_LIST: StaticSchema = ( 16, n1, _XNL, @@ -2596,7 +2702,7 @@ ((3, {_sNm: MappingProxyType({"uri": "http://bux.com"})}),), ) -XML_NAMESPACE_NESTED = ( +XML_NAMESPACE_NESTED: StaticSchema = ( 18, n1, _XNN, @@ -2608,7 +2714,7 @@ ), ) -XML_NAMESPACES_INPUT = ( +XML_NAMESPACES_INPUT: StaticSchema = ( 18, n1, _XNI, @@ -2617,7 +2723,7 @@ ((XML_NAMESPACE_NESTED, 0),), ) -XML_NAMESPACES_OUTPUT = ( +XML_NAMESPACES_OUTPUT: StaticSchema = ( 18, n1, _XNO, @@ -2626,7 +2732,7 @@ ((XML_NAMESPACE_NESTED, 0),), ) -XML_NAMESPACES = ( +XML_NAMESPACES: StaticOperationSchema = ( 23, n1, _XN, @@ -2636,7 +2742,7 @@ (), ) -XML_TIMESTAMPS_INPUT = ( +XML_TIMESTAMPS_INPUT: StaticSchema = ( 18, n1, _XTI, @@ -2653,7 +2759,7 @@ ), ) -XML_TIMESTAMPS_OUTPUT = ( +XML_TIMESTAMPS_OUTPUT: StaticSchema = ( 18, n1, _XTO, @@ -2670,7 +2776,7 @@ ), ) -XML_TIMESTAMPS = ( +XML_TIMESTAMPS: StaticOperationSchema = ( 23, n1, _XTm, @@ -2680,7 +2786,7 @@ (), ) -XML_NESTED_UNION_STRUCT = ( +XML_NESTED_UNION_STRUCT: StaticSchema = ( 18, n1, _XNUS, @@ -2689,7 +2795,7 @@ ((3, 0), (2, 0), (5, 0), (6, 0), (7, 0), (8, 0), (9, 0), (10, 0)), ) -XML_UNION_SHAPE = ( # pyright: ignore[reportUnknownVariableType] +XML_UNION_SHAPE: StaticSchema = ( 19, n1, _XUS, @@ -2704,24 +2810,21 @@ (8, 0), (9, 0), (10, 0), - (lambda: XML_UNION_SHAPE, 0), # pyright: ignore[reportUnknownLambdaType] + (lambda: XML_UNION_SHAPE, 0), (XML_NESTED_UNION_STRUCT, 0), ), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1: StaticSchema = ( 18, n1, _RSION, 0, (_f, _ne), - ( - (3, 0), - (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] - ), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2: StaticSchema = ( 18, n1, _RSIONe, @@ -2730,7 +2833,7 @@ ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), ) -XML_UNIONS_INPUT = ( # pyright: ignore[reportUnknownVariableType] +XML_UNIONS_INPUT: StaticSchema = ( 18, n1, _XUI, @@ -2739,7 +2842,7 @@ ((XML_UNION_SHAPE, 0),), ) -XML_UNIONS_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +XML_UNIONS_OUTPUT: StaticSchema = ( 18, n1, _XUO, @@ -2748,7 +2851,7 @@ ((XML_UNION_SHAPE, 0),), ) -RECURSIVE_SHAPES_INPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT: StaticSchema = ( 18, n1, _RSI, @@ -2757,7 +2860,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_OUTPUT: StaticSchema = ( 18, n1, _RSO, @@ -2766,7 +2869,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -XML_UNIONS = ( # pyright: ignore[reportUnknownVariableType] +XML_UNIONS: StaticOperationSchema = ( 23, n1, _XU, @@ -2776,7 +2879,7 @@ (), ) -RECURSIVE_SHAPES = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES: StaticOperationSchema = ( 23, n1, _RS, @@ -2786,7 +2889,7 @@ (), ) -REST_XML = ( +REST_XML: StaticSchema = ( 21, n1, _RX, @@ -2942,8 +3045,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "Endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -2955,8 +3058,8 @@ "endpoint": MappingProxyType( { "url": "https://restxml-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -2975,8 +3078,8 @@ "endpoint": MappingProxyType( { "url": "https://restxml.{Region}.amazonaws.com", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -2988,8 +3091,8 @@ "endpoint": MappingProxyType( { "url": "https://restxml-fips.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -3008,8 +3111,8 @@ "endpoint": MappingProxyType( { "url": "https://restxml.{Region}.{PartitionResult#dualStackDnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", @@ -3028,8 +3131,8 @@ "endpoint": MappingProxyType( { "url": "https://restxml.{Region}.{PartitionResult#dnsSuffix}", - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py b/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py index bf2b9986a..bc2cf6a28 100644 --- a/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py +++ b/codegen-output/rpcv2-cbor/src/rpcv2cbor/_private/schemas.py @@ -2,6 +2,8 @@ from types import MappingProxyType +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + n0 = "smithy.framework" _VEF = "ValidationExceptionField" @@ -203,9 +205,9 @@ _sC = "smithy.protocols#rpcv2Cbor" _sB = "smithy.rules#endpointBdd" -VALIDATION_EXCEPTION_FIELD = (18, n0, _VEF, 0, (_p, _m), ((3, 1), (3, 1))) +VALIDATION_EXCEPTION_FIELD: StaticSchema = (18, n0, _VEF, 0, (_p, _m), ((3, 1), (3, 1))) -VALIDATION_EXCEPTION_FIELD_LIST = ( +VALIDATION_EXCEPTION_FIELD_LIST: StaticSchema = ( 16, n0, _VEFL, @@ -214,7 +216,7 @@ ((VALIDATION_EXCEPTION_FIELD, 0),), ) -VALIDATION_EXCEPTION = ( +VALIDATION_EXCEPTION: StaticSchema = ( 18, n0, _VE, @@ -223,11 +225,11 @@ ((3, 1), (VALIDATION_EXCEPTION_FIELD_LIST, 0)), ) -CLIENT_OPTIONAL_DEFAULTS = (18, n1, _COD, 0, (_me,), ((7, {_smi: 0}),)) +CLIENT_OPTIONAL_DEFAULTS: StaticSchema = (18, n1, _COD, 0, (_me,), ((7, {_smi: 0}),)) -COMPLEX_NESTED_ERROR_DATA = (18, n1, _CNED, 0, (_F,), ((3, 0),)) +COMPLEX_NESTED_ERROR_DATA: StaticSchema = (18, n1, _CNED, 0, (_F,), ((3, 0),)) -COMPLEX_ERROR = ( +COMPLEX_ERROR: StaticSchema = ( 18, n1, _CE, @@ -236,15 +238,22 @@ ((3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), ) -TEST_ENUM = (14, n1, _TE, 0, (_FOO, _BAR, _BAZ), ((-1, 0), (-1, 0), (-1, 0))) +TEST_ENUM: StaticSchema = ( + 14, + n1, + _TE, + 0, + (_FOO, _BAR, _BAZ), + ((-1, 0), (-1, 0), (-1, 0)), +) -TEST_INT_ENUM = (15, n1, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) +TEST_INT_ENUM: StaticSchema = (15, n1, _TIE, 0, (_ONE, _TWO), ((-1, 0), (-1, 0))) -TEST_STRING_LIST = (16, n1, _TSL, 0, (_me,), ((3, 0),)) +TEST_STRING_LIST: StaticSchema = (16, n1, _TSL, 0, (_me,), ((3, 0),)) -TEST_STRING_MAP = (17, n1, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) +TEST_STRING_MAP: StaticSchema = (17, n1, _TSM, 0, (_k, _v), ((3, 0), (3, 0))) -DEFAULTS = ( +DEFAULTS: StaticSchema = ( 18, n1, _D, @@ -301,25 +310,32 @@ ), ) -DENSE_BOOLEAN_MAP = (17, n1, _DBM, 0, (_k, _v), ((3, 0), (2, 0))) +DENSE_BOOLEAN_MAP: StaticSchema = (17, n1, _DBM, 0, (_k, _v), ((3, 0), (2, 0))) -DENSE_NUMBER_MAP = (17, n1, _DNM, 0, (_k, _v), ((3, 0), (7, 0))) +DENSE_NUMBER_MAP: StaticSchema = (17, n1, _DNM, 0, (_k, _v), ((3, 0), (7, 0))) -STRING_SET = (16, n2, _SS, 0, (_me,), ((3, 0),)) +STRING_SET: StaticSchema = (16, n2, _SS, 0, (_me,), ((3, 0),)) -DENSE_SET_MAP = (17, n1, _DSM, 0, (_k, _v), ((3, 0), (STRING_SET, 0))) +DENSE_SET_MAP: StaticSchema = (17, n1, _DSM, 0, (_k, _v), ((3, 0), (STRING_SET, 0))) -DENSE_STRING_MAP = (17, n1, _DSMe, 0, (_k, _v), ((3, 0), (3, 0))) +DENSE_STRING_MAP: StaticSchema = (17, n1, _DSMe, 0, (_k, _v), ((3, 0), (3, 0))) -GREETING_STRUCT = (18, n2, _GS, 0, (_h,), ((3, 0),)) +GREETING_STRUCT: StaticSchema = (18, n2, _GS, 0, (_h,), ((3, 0),)) -DENSE_STRUCT_MAP = (17, n1, _DSMen, 0, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) +DENSE_STRUCT_MAP: StaticSchema = ( + 17, + n1, + _DSMen, + 0, + (_k, _v), + ((3, 0), (GREETING_STRUCT, 0)), +) -EMPTY_INPUT_OUTPUT_INPUT = (18, n1, _EIOI, {_sSI: _sCES}) +EMPTY_INPUT_OUTPUT_INPUT: StaticSchema = (18, n1, _EIOI, {_sSI: _sCES}) -EMPTY_INPUT_OUTPUT_OUTPUT = (18, n1, _EIOO, {_sSI: _sCES}) +EMPTY_INPUT_OUTPUT_OUTPUT: StaticSchema = (18, n1, _EIOO, {_sSI: _sCES}) -EMPTY_INPUT_OUTPUT = ( +EMPTY_INPUT_OUTPUT: StaticOperationSchema = ( 23, n1, _EIO, @@ -329,19 +345,19 @@ (), ) -FLOAT16_INPUT = (18, n1, _FI, {_sSI: _sU}) +FLOAT16_INPUT: StaticSchema = (18, n1, _FI, {_sSI: _sU}) -FLOAT16_OUTPUT = (18, n1, _FO, 0, (_v,), ((10, 0),)) +FLOAT16_OUTPUT: StaticSchema = (18, n1, _FO, 0, (_v,), ((10, 0),)) -FLOAT16 = (23, n1, _Fl, 0, FLOAT16_INPUT, FLOAT16_OUTPUT, ()) +FLOAT16: StaticOperationSchema = (23, n1, _Fl, 0, FLOAT16_INPUT, FLOAT16_OUTPUT, ()) -FRACTIONAL_SECONDS_INPUT = (18, n1, _FSI, {_sSI: _sU}) +FRACTIONAL_SECONDS_INPUT: StaticSchema = (18, n1, _FSI, {_sSI: _sU}) -DATE_TIME = (4, n2, _DT, {_sF: _dt}) +DATE_TIME: StaticSchema = (4, n2, _DT, {_sF: _dt}) -FRACTIONAL_SECONDS_OUTPUT = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = (18, n1, _FSO, 0, (_d,), ((DATE_TIME, 0),)) -FRACTIONAL_SECONDS = ( +FRACTIONAL_SECONDS: StaticOperationSchema = ( 23, n1, _FS, @@ -351,13 +367,13 @@ (), ) -GREETING_WITH_ERRORS_INPUT = (18, n1, _GWEI, {_sSI: _sU}) +GREETING_WITH_ERRORS_INPUT: StaticSchema = (18, n1, _GWEI, {_sSI: _sU}) -GREETING_WITH_ERRORS_OUTPUT = (18, n1, _GWEO, 0, (_g,), ((3, 0),)) +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = (18, n1, _GWEO, 0, (_g,), ((3, 0),)) -INVALID_GREETING = (18, n1, _IG, {_sm: _c}, (_M,), ((3, 0),)) +INVALID_GREETING: StaticSchema = (18, n1, _IG, {_sm: _c}, (_M,), ((3, 0),)) -GREETING_WITH_ERRORS = ( +GREETING_WITH_ERRORS: StaticOperationSchema = ( 23, n1, _GWE, @@ -367,13 +383,21 @@ (INVALID_GREETING, COMPLEX_ERROR), ) -NO_INPUT_OUTPUT_INPUT = (18, n1, _NIOI, {_sSI: _sU}) +NO_INPUT_OUTPUT_INPUT: StaticSchema = (18, n1, _NIOI, {_sSI: _sU}) -NO_INPUT_OUTPUT_OUTPUT = (18, n1, _NIOO, {_sSI: _sU}) +NO_INPUT_OUTPUT_OUTPUT: StaticSchema = (18, n1, _NIOO, {_sSI: _sU}) -NO_INPUT_OUTPUT = (23, n1, _NIO, 0, NO_INPUT_OUTPUT_INPUT, NO_INPUT_OUTPUT_OUTPUT, ()) +NO_INPUT_OUTPUT: StaticOperationSchema = ( + 23, + n1, + _NIO, + 0, + NO_INPUT_OUTPUT_INPUT, + NO_INPUT_OUTPUT_OUTPUT, + (), +) -OPERATION_WITH_DEFAULTS_INPUT = ( +OPERATION_WITH_DEFAULTS_INPUT: StaticSchema = ( 18, n1, _OWDI, @@ -382,7 +406,7 @@ ((DEFAULTS, 0), (CLIENT_OPTIONAL_DEFAULTS, 0), (3, {_smi: _h}), (7, {_smi: 0})), ) -OPERATION_WITH_DEFAULTS_OUTPUT = ( +OPERATION_WITH_DEFAULTS_OUTPUT: StaticSchema = ( 18, n1, _OWDO, @@ -439,7 +463,7 @@ ), ) -OPERATION_WITH_DEFAULTS = ( +OPERATION_WITH_DEFAULTS: StaticOperationSchema = ( 23, n1, _OWD, @@ -449,11 +473,25 @@ (VALIDATION_EXCEPTION,), ) -OPTIONAL_INPUT_OUTPUT_INPUT = (18, n1, _OIOI, {_sSI: _sCSS}, (_v,), ((3, 0),)) +OPTIONAL_INPUT_OUTPUT_INPUT: StaticSchema = ( + 18, + n1, + _OIOI, + {_sSI: _sCSS}, + (_v,), + ((3, 0),), +) -OPTIONAL_INPUT_OUTPUT_OUTPUT = (18, n1, _OIOO, {_sSI: _sCSS}, (_v,), ((3, 0),)) +OPTIONAL_INPUT_OUTPUT_OUTPUT: StaticSchema = ( + 18, + n1, + _OIOO, + {_sSI: _sCSS}, + (_v,), + ((3, 0),), +) -OPTIONAL_INPUT_OUTPUT = ( +OPTIONAL_INPUT_OUTPUT: StaticOperationSchema = ( 23, n1, _OIO, @@ -463,7 +501,7 @@ (), ) -RPC_V2_CBOR_DENSE_MAPS_INPUT = ( +RPC_V2_CBOR_DENSE_MAPS_INPUT: StaticSchema = ( 18, n1, _RVCDMI, @@ -478,7 +516,7 @@ ), ) -RPC_V2_CBOR_DENSE_MAPS_OUTPUT = ( +RPC_V2_CBOR_DENSE_MAPS_OUTPUT: StaticSchema = ( 18, n1, _RVCDMO, @@ -493,7 +531,7 @@ ), ) -RPC_V2_CBOR_DENSE_MAPS = ( +RPC_V2_CBOR_DENSE_MAPS: StaticOperationSchema = ( 23, n1, _RVCDM, @@ -503,11 +541,11 @@ (VALIDATION_EXCEPTION,), ) -BLOB_LIST = (16, n2, _BL, 0, (_me,), ((1, 0),)) +BLOB_LIST: StaticSchema = (16, n2, _BL, 0, (_me,), ((1, 0),)) -BOOLEAN_LIST = (16, n2, _BLo, 0, (_me,), ((2, 0),)) +BOOLEAN_LIST: StaticSchema = (16, n2, _BLo, 0, (_me,), ((2, 0),)) -FOO_ENUM = ( +FOO_ENUM: StaticSchema = ( 14, n2, _FE, @@ -516,25 +554,25 @@ ((-1, 0), (-1, 0), (-1, 0), (-1, 0), (-1, 0)), ) -FOO_ENUM_LIST = (16, n2, _FEL, 0, (_me,), ((FOO_ENUM, 0),)) +FOO_ENUM_LIST: StaticSchema = (16, n2, _FEL, 0, (_me,), ((FOO_ENUM, 0),)) -INTEGER_LIST = (16, n2, _IL, 0, (_me,), ((7, 0),)) +INTEGER_LIST: StaticSchema = (16, n2, _IL, 0, (_me,), ((7, 0),)) -INTEGER_ENUM = (15, n2, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) +INTEGER_ENUM: StaticSchema = (15, n2, _IE, 0, (_A, _B, _C), ((-1, 0), (-1, 0), (-1, 0))) -INTEGER_ENUM_LIST = (16, n2, _IEL, 0, (_me,), ((INTEGER_ENUM, 0),)) +INTEGER_ENUM_LIST: StaticSchema = (16, n2, _IEL, 0, (_me,), ((INTEGER_ENUM, 0),)) -STRING_LIST = (16, n2, _SL, 0, (_me,), ((3, 0),)) +STRING_LIST: StaticSchema = (16, n2, _SL, 0, (_me,), ((3, 0),)) -NESTED_STRING_LIST = (16, n2, _NSL, 0, (_me,), ((STRING_LIST, 0),)) +NESTED_STRING_LIST: StaticSchema = (16, n2, _NSL, 0, (_me,), ((STRING_LIST, 0),)) -STRUCTURE_LIST_MEMBER = (18, n1, _SLM, 0, (_a, _b), ((3, 0), (3, 0))) +STRUCTURE_LIST_MEMBER: StaticSchema = (18, n1, _SLM, 0, (_a, _b), ((3, 0), (3, 0))) -STRUCTURE_LIST = (16, n1, _SLt, 0, (_me,), ((STRUCTURE_LIST_MEMBER, 0),)) +STRUCTURE_LIST: StaticSchema = (16, n1, _SLt, 0, (_me,), ((STRUCTURE_LIST_MEMBER, 0),)) -TIMESTAMP_LIST = (16, n2, _TLi, 0, (_me,), ((4, 0),)) +TIMESTAMP_LIST: StaticSchema = (16, n2, _TLi, 0, (_me,), ((4, 0),)) -RPC_V2_CBOR_LISTS_INPUT = ( +RPC_V2_CBOR_LISTS_INPUT: StaticSchema = ( 18, n1, _RVCLI, @@ -554,7 +592,7 @@ ), ) -RPC_V2_CBOR_LISTS_OUTPUT = ( +RPC_V2_CBOR_LISTS_OUTPUT: StaticSchema = ( 18, n1, _RVCLO, @@ -574,7 +612,7 @@ ), ) -RPC_V2_CBOR_LISTS = ( +RPC_V2_CBOR_LISTS: StaticOperationSchema = ( 23, n1, _RVCL, @@ -584,19 +622,26 @@ (VALIDATION_EXCEPTION,), ) -RPC_V2_CBOR_NESTED_UNION = (19, n1, _RVCNU, 0, (_sV,), ((3, 0),)) +RPC_V2_CBOR_NESTED_UNION: StaticSchema = (19, n1, _RVCNU, 0, (_sV,), ((3, 0),)) -SPARSE_BOOLEAN_MAP = (17, n1, _SBM, 64, (_k, _v), ((3, 0), (2, 0))) +SPARSE_BOOLEAN_MAP: StaticSchema = (17, n1, _SBM, 64, (_k, _v), ((3, 0), (2, 0))) -SPARSE_NUMBER_MAP = (17, n1, _SNM, 64, (_k, _v), ((3, 0), (7, 0))) +SPARSE_NUMBER_MAP: StaticSchema = (17, n1, _SNM, 64, (_k, _v), ((3, 0), (7, 0))) -SPARSE_SET_MAP = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (STRING_SET, 0))) +SPARSE_SET_MAP: StaticSchema = (17, n1, _SSM, 64, (_k, _v), ((3, 0), (STRING_SET, 0))) -SPARSE_STRING_MAP = (17, n2, _SSMp, 64, (_k, _v), ((3, 0), (3, 0))) +SPARSE_STRING_MAP: StaticSchema = (17, n2, _SSMp, 64, (_k, _v), ((3, 0), (3, 0))) -SPARSE_STRUCT_MAP = (17, n1, _SSMpa, 64, (_k, _v), ((3, 0), (GREETING_STRUCT, 0))) +SPARSE_STRUCT_MAP: StaticSchema = ( + 17, + n1, + _SSMpa, + 64, + (_k, _v), + ((3, 0), (GREETING_STRUCT, 0)), +) -RPC_V2_CBOR_SPARSE_MAPS_INPUT = ( +RPC_V2_CBOR_SPARSE_MAPS_INPUT: StaticSchema = ( 18, n1, _RVCSMI, @@ -611,7 +656,7 @@ ), ) -RPC_V2_CBOR_SPARSE_MAPS_OUTPUT = ( +RPC_V2_CBOR_SPARSE_MAPS_OUTPUT: StaticSchema = ( 18, n1, _RVCSMO, @@ -626,7 +671,7 @@ ), ) -RPC_V2_CBOR_SPARSE_MAPS = ( +RPC_V2_CBOR_SPARSE_MAPS: StaticOperationSchema = ( 23, n1, _RVCSM, @@ -636,7 +681,7 @@ (VALIDATION_EXCEPTION,), ) -RPC_V2_CBOR_UNION = ( +RPC_V2_CBOR_UNION: StaticSchema = ( 19, n1, _RVCU, @@ -645,7 +690,7 @@ ((3, 0), (RPC_V2_CBOR_NESTED_UNION, 0)), ) -RPC_V2_CBOR_UNIONS_INPUT = ( +RPC_V2_CBOR_UNIONS_INPUT: StaticSchema = ( 18, n1, _RVCUI, @@ -654,7 +699,7 @@ ((RPC_V2_CBOR_UNION, 0), (3, 0)), ) -RPC_V2_CBOR_UNIONS_OUTPUT = ( +RPC_V2_CBOR_UNIONS_OUTPUT: StaticSchema = ( 18, n1, _RVCUO, @@ -663,7 +708,7 @@ ((RPC_V2_CBOR_UNION, 0), (3, 0)), ) -RPC_V2_CBOR_UNIONS = ( +RPC_V2_CBOR_UNIONS: StaticOperationSchema = ( 23, n1, _RVCUp, @@ -673,7 +718,7 @@ (), ) -SIMPLE_SCALAR_PROPERTIES_INPUT = ( +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( 18, n1, _SSPI, @@ -682,7 +727,7 @@ ((2, 0), (2, 0), (5, 0), (10, 0), (9, 0), (7, 0), (8, 0), (6, 0), (3, 0), (1, 0)), ) -SIMPLE_SCALAR_PROPERTIES_OUTPUT = ( +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( 18, n1, _SSPO, @@ -691,7 +736,7 @@ ((2, 0), (2, 0), (5, 0), (10, 0), (9, 0), (7, 0), (8, 0), (6, 0), (3, 0), (1, 0)), ) -SIMPLE_SCALAR_PROPERTIES = ( +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( 23, n1, _SSP, @@ -701,9 +746,9 @@ (), ) -SPARSE_STRING_LIST = (16, n2, _SSL, 64, (_me,), ((3, 0),)) +SPARSE_STRING_LIST: StaticSchema = (16, n2, _SSL, 64, (_me,), ((3, 0),)) -SPARSE_NULLS_OPERATION_INPUT = ( +SPARSE_NULLS_OPERATION_INPUT: StaticSchema = ( 18, n1, _SNOI, @@ -712,7 +757,7 @@ ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), ) -SPARSE_NULLS_OPERATION_OUTPUT = ( +SPARSE_NULLS_OPERATION_OUTPUT: StaticSchema = ( 18, n1, _SNOO, @@ -721,7 +766,7 @@ ((SPARSE_STRING_LIST, 0), (SPARSE_STRING_MAP, 0)), ) -SPARSE_NULLS_OPERATION = ( +SPARSE_NULLS_OPERATION: StaticOperationSchema = ( 23, n1, _SNO, @@ -731,19 +776,16 @@ (), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1: StaticSchema = ( 18, n1, _RSION, 0, (_f, _n), - ( - (3, 0), - (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0), # pyright: ignore[reportUnknownLambdaType] - ), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), ) -RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2 = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2: StaticSchema = ( 18, n1, _RSIONe, @@ -752,7 +794,7 @@ ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), ) -RECURSIVE_SHAPES_INPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_INPUT: StaticSchema = ( 18, n1, _RSI, @@ -761,7 +803,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES_OUTPUT = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES_OUTPUT: StaticSchema = ( 18, n1, _RSO, @@ -770,7 +812,7 @@ ((RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), ) -RECURSIVE_SHAPES = ( # pyright: ignore[reportUnknownVariableType] +RECURSIVE_SHAPES: StaticOperationSchema = ( 23, n1, _RS, @@ -780,7 +822,7 @@ (), ) -RPC_V2_PROTOCOL = ( +RPC_V2_PROTOCOL: StaticSchema = ( 21, n1, _RVP, @@ -816,8 +858,8 @@ "endpoint": MappingProxyType( { "url": MappingProxyType({"ref": "endpoint"}), - "properties": MappingProxyType({}), - "headers": MappingProxyType({}), + "properties": MappingProxyType[str, object]({}), + "headers": MappingProxyType[str, object]({}), } ), "type": "endpoint", diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java index a676440a2..6d476eb91 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/RuntimeTypes.java @@ -26,6 +26,10 @@ public final class RuntimeTypes { // smithy_core._schema_compact public static final Symbol HYDRATE = createSymbol("_schema_compact", "hydrate", SmithyPythonDependency.SMITHY_CORE); + public static final Symbol STATIC_SCHEMA = + createSymbol("_schema_compact", "StaticSchema", SmithyPythonDependency.SMITHY_CORE); + public static final Symbol STATIC_OPERATION_SCHEMA = + createSymbol("_schema_compact", "StaticOperationSchema", SmithyPythonDependency.SMITHY_CORE); // smithy_core.shapes public static final Symbol SHAPE_ID = createSymbol("shapes", "ShapeID", SmithyPythonDependency.SMITHY_CORE); diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java index bf12dfcb4..2213b811b 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/SchemaGenerator.java @@ -28,6 +28,7 @@ import software.amazon.smithy.model.shapes.ShapeType; import software.amazon.smithy.model.traits.UnitTypeTrait; import software.amazon.smithy.python.codegen.GenerationContext; +import software.amazon.smithy.python.codegen.RuntimeTypes; import software.amazon.smithy.python.codegen.SchemaTraitFilterIndex; import software.amazon.smithy.python.codegen.SymbolProperties; import software.amazon.smithy.python.codegen.writer.PythonWriter; @@ -100,11 +101,6 @@ public final class SchemaGenerator implements Consumer { // initialism and preferred-prefix allocation paths. private final Set allocated = new HashSet<>(); - // Shapes whose emitted tuple holds an unknown-typed value (a lambda, or a - // reference to another tainted shape). Their assignment lines get an inline - // reportUnknownVariableType ignore; nothing else does. - private final Set tainted = new HashSet<>(); - public SchemaGenerator(GenerationContext context) { this.context = context; } @@ -254,16 +250,13 @@ private void writeShape(PythonWriter writer, Shape shape) { int typeInt = typeInt(shape); var key = schemaName(shape); - boolean shapeTainted = computeTaint(shape); - if (shapeTainted) { - tainted.add(shape.getId()); - } - // The ignore rides the opening line as a trailing comment; the tuple continues - // across the following lines unaffected. - var opener = shapeTainted - ? "$L = ( # pyright: ignore[reportUnknownVariableType]" - : "$L = ("; - writer.write(opener, key); + // Annotate the global with its static-schema alias so a forward/recursive + // lambda member doesn't leave the inferred tuple type partially unknown, which + // otherwise leaks to every import and APIOperation(static_schema=) call site. + var typeSymbol = shape.isOperationShape() + ? RuntimeTypes.STATIC_OPERATION_SCHEMA + : RuntimeTypes.STATIC_SCHEMA; + writer.write("$L: $T = (", key, typeSymbol); writer.writeInline("$L, $L, $L, ", Integer.toString(typeInt), nsConst, nameConst); writeTraits(writer, traits); @@ -290,26 +283,6 @@ private void writeShape(PythonWriter writer, Shape shape) { written.add(shape.getId()); } - // A shape is unknown-tainted if any of its references is a lambda (forward or - // recursive) or points at an already-tainted shape; operations also consider their - // input, output, and error refs. Computed before emission so the opening line can - // carry the inline ignore. - private boolean computeTaint(Shape shape) { - if (shape.isOperationShape()) { - var op = shape.asOperationShape().get(); - var refs = new ArrayList(); - refs.add(op.getInputShape()); - refs.add(op.getOutputShape()); - refs.addAll(op.getErrors()); - return refs.stream().anyMatch(this::refTainted); - } - return shape.members().stream().anyMatch(m -> refTainted(m.getTarget())); - } - - private boolean refTainted(ShapeId target) { - return isLambdaTarget(target) || tainted.contains(target); - } - // Operation tuple trailing slots: input_ref, output_ref, (error_refs...). Matches // _schema_compact._OP_INPUT / _OP_OUTPUT / _OP_ERRORS. private void writeOperationRefs(PythonWriter writer, OperationShape op) { @@ -320,7 +293,7 @@ private void writeOperationRefs(PythonWriter writer, OperationShape op) { for (var error : op.getErrors()) { writer.writeInline(""); writeSchemaRef(writer, error); - writer.write(errorRefSuffix(error)); + writer.write(","); } }); } @@ -328,15 +301,7 @@ private void writeOperationRefs(PythonWriter writer, OperationShape op) { private void writeOperationRef(PythonWriter writer, ShapeId target) { writer.writeInline(""); writeSchemaRef(writer, target); - writer.write(isLambdaTarget(target) - ? ", # pyright: ignore[reportUnknownLambdaType]" - : ","); - } - - private String errorRefSuffix(ShapeId target) { - return isLambdaTarget(target) - ? ", # pyright: ignore[reportUnknownLambdaType]" - : ","; + writer.write(","); } private String schemaName(Shape shape) { @@ -359,24 +324,10 @@ private void writeMemberTargets(PythonWriter writer, Shape shape) { for (var member : shape.members()) { writer.writeInline(""); writeMemberTarget(writer, member); - // Only an actual lambda line carries a lambda-return type pyright can't - // resolve; a tainted bare sibling is handled by the shape's opener ignore. - if (isLambdaTarget(member.getTarget())) { - writer.write(", # pyright: ignore[reportUnknownLambdaType]"); - } else { - writer.write(","); - } + writer.write(","); } } - // A member target emits a lambda when it is a non-prelude shape not yet defined in - // file order (a forward or recursive reference). - private boolean isLambdaTarget(ShapeId target) { - return !target.equals(UnitTypeTrait.UNIT) - && !PRELUDE_INTS.containsKey(target.toString()) - && !written.contains(target); - } - private void writeMemberTarget(PythonWriter writer, MemberShape member) { var memberTraits = filterTraits(member); writer.writeInline("("); diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/writer/PythonWriter.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/writer/PythonWriter.java index 3808dc9a3..1888ff3a8 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/writer/PythonWriter.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/writer/PythonWriter.java @@ -636,7 +636,10 @@ public String arrayNode(ArrayNode node) { public String objectNode(ObjectNode node) { writer.addStdlibImport("types", "MappingProxyType"); if (node.getMembers().isEmpty()) { - return "MappingProxyType({})"; + // An unparameterized empty literal infers MappingProxyType[Unknown, + // Unknown], which leaks partially-unknown up through every enclosing + // trait value under strict pyright. + return "MappingProxyType[str, object]({})"; } StringBuilder builder = new StringBuilder("MappingProxyType({\n"); From 807d4647a92cc092409c03a999cf53ba20a48b6f Mon Sep 17 00:00:00 2001 From: George Fu Date: Tue, 13 Oct 2026 20:44:14 +0000 Subject: [PATCH 6/6] Finalize schema components before caching; dedupe member generators Hold every node of a connected schema graph out of the shared hydrate cache until the outermost frame completes, so a cross-referenced sibling is never published pointing at a half-built node. Extract AbstractMemberGenerator for the writeSchema/memberIndex logic shared by the member ser/deser generators. --- .../generators/AbstractMemberGenerator.java | 54 ++++++++++ .../MemberDeserializerGenerator.java | 32 +----- .../generators/MemberSerializerGenerator.java | 35 +------ .../src/smithy_core/_schema_compact.py | 99 +++++++++++-------- .../tests/unit/test_schema_compact.py | 43 ++++++++ 5 files changed, 160 insertions(+), 103 deletions(-) create mode 100644 codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/AbstractMemberGenerator.java diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/AbstractMemberGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/AbstractMemberGenerator.java new file mode 100644 index 000000000..864e4eece --- /dev/null +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/AbstractMemberGenerator.java @@ -0,0 +1,54 @@ +/* + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package software.amazon.smithy.python.codegen.generators; + +import software.amazon.smithy.codegen.core.CodegenException; +import software.amazon.smithy.model.shapes.MemberShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.ShapeVisitor; +import software.amazon.smithy.python.codegen.GenerationContext; +import software.amazon.smithy.python.codegen.writer.PythonWriter; +import software.amazon.smithy.utils.SmithyInternalApi; + +/** + * Shared base for the member serializer and deserializer generators, holding the + * schema-location logic that is identical between the two directions. + */ +@SmithyInternalApi +abstract class AbstractMemberGenerator extends ShapeVisitor.DataShapeVisitor { + + protected final GenerationContext context; + protected final PythonWriter writer; + protected final MemberShape member; + + AbstractMemberGenerator(GenerationContext context, PythonWriter writer, MemberShape member) { + this.context = context; + this.writer = writer; + this.member = member; + } + + /** A list/map member reaches its schema through the container's element schema. */ + protected void writeSchema() { + var parent = context.model().expectShape(member.getContainer()); + if (parent.isListShape()) { + writer.writeInline("member_schema"); + } else if (parent.isMapShape()) { + writer.writeInline("value_schema"); + } else { + writer.writeInline("members[$L]", Integer.toString(memberIndex(parent))); + } + } + + protected int memberIndex(Shape parent) { + int index = 0; + for (var m : parent.members()) { + if (m.getMemberName().equals(member.getMemberName())) { + return index; + } + index++; + } + throw new CodegenException("Member not found in container: " + member.getId()); + } +} diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java index fcd0bcaea..d38a598c9 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberDeserializerGenerator.java @@ -22,7 +22,6 @@ import software.amazon.smithy.model.shapes.MapShape; import software.amazon.smithy.model.shapes.MemberShape; import software.amazon.smithy.model.shapes.Shape; -import software.amazon.smithy.model.shapes.ShapeVisitor; import software.amazon.smithy.model.shapes.ShortShape; import software.amazon.smithy.model.shapes.StringShape; import software.amazon.smithy.model.shapes.StructureShape; @@ -38,11 +37,8 @@ * Generates calls to shape serializers for member shapes. */ @SmithyInternalApi -public class MemberDeserializerGenerator extends ShapeVisitor.DataShapeVisitor { +public class MemberDeserializerGenerator extends AbstractMemberGenerator { - private final GenerationContext context; - private final PythonWriter writer; - private final MemberShape member; private final String deserializerName; public MemberDeserializerGenerator( @@ -51,9 +47,7 @@ public MemberDeserializerGenerator( MemberShape member, String deserializerName ) { - this.context = context; - this.writer = writer; - this.member = member; + super(context, writer, member); this.deserializerName = deserializerName; } @@ -88,28 +82,6 @@ private void writeDeserializer(String shapeTypeName) { //writer.popState(); } - private void writeSchema() { - var parent = context.model().expectShape(member.getContainer()); - if (parent.isListShape()) { - writer.writeInline("member_schema"); - } else if (parent.isMapShape()) { - writer.writeInline("value_schema"); - } else { - writer.writeInline("members[$L]", Integer.toString(memberIndex(parent))); - } - } - - private int memberIndex(Shape parent) { - int index = 0; - for (var m : parent.members()) { - if (m.getMemberName().equals(member.getMemberName())) { - return index; - } - index++; - } - throw new CodegenException("Member not found in container: " + member.getId()); - } - @Override public Void blobShape(BlobShape shape) { if (shape.hasTrait(StreamingTrait.class)) { diff --git a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java index 40a395dfc..b214710ea 100644 --- a/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java +++ b/codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/MemberSerializerGenerator.java @@ -5,7 +5,6 @@ package software.amazon.smithy.python.codegen.generators; import java.util.Locale; -import java.util.logging.Logger; import software.amazon.smithy.codegen.core.CodegenException; import software.amazon.smithy.model.shapes.BigDecimalShape; import software.amazon.smithy.model.shapes.BigIntegerShape; @@ -23,7 +22,6 @@ import software.amazon.smithy.model.shapes.MapShape; import software.amazon.smithy.model.shapes.MemberShape; import software.amazon.smithy.model.shapes.Shape; -import software.amazon.smithy.model.shapes.ShapeVisitor; import software.amazon.smithy.model.shapes.ShortShape; import software.amazon.smithy.model.shapes.StringShape; import software.amazon.smithy.model.shapes.StructureShape; @@ -39,13 +37,8 @@ * Generates calls to shape serializers for member shapes. */ @SmithyInternalApi -public final class MemberSerializerGenerator extends ShapeVisitor.DataShapeVisitor { +public final class MemberSerializerGenerator extends AbstractMemberGenerator { - private static final Logger LOGGER = Logger.getLogger(MemberSerializerGenerator.class.getName()); - - private final GenerationContext context; - private final PythonWriter writer; - private final MemberShape member; private final String serializerName; public MemberSerializerGenerator( @@ -54,9 +47,7 @@ public MemberSerializerGenerator( MemberShape member, String serializerName ) { - this.context = context; - this.writer = writer; - this.member = member; + super(context, writer, member); this.serializerName = serializerName; } @@ -95,28 +86,6 @@ private void writeSerializer(String typeName) { } - private void writeSchema() { - var parent = context.model().expectShape(member.getContainer()); - if (parent.isListShape()) { - writer.writeInline("member_schema"); - } else if (parent.isMapShape()) { - writer.writeInline("value_schema"); - } else { - writer.writeInline("members[$L]", Integer.toString(memberIndex(parent))); - } - } - - private int memberIndex(Shape parent) { - int index = 0; - for (var m : parent.members()) { - if (m.getMemberName().equals(member.getMemberName())) { - return index; - } - index++; - } - throw new CodegenException("Member not found in container: " + member.getId()); - } - @Override public Void blobShape(BlobShape shape) { if (shape.hasTrait(StreamingTrait.class)) { diff --git a/packages/smithy-core/src/smithy_core/_schema_compact.py b/packages/smithy-core/src/smithy_core/_schema_compact.py index 9f04d1b0e..841ee3da7 100644 --- a/packages/smithy-core/src/smithy_core/_schema_compact.py +++ b/packages/smithy-core/src/smithy_core/_schema_compact.py @@ -131,18 +131,20 @@ def _resolve(ref: "StaticSchemaRef") -> Schema: return _resolve(ref()) -# id(tuple) -> fully hydrated Schema. A tuple is written here only once its members -# id(tuple) -> (tuple, fully hydrated Schema). A tuple is written here only once its -# members are fully resolved, so a reader never sees a half-built schema. The value -# keeps a reference to the keyed tuple so its id() can't be recycled onto a different -# tuple while cached -- which would otherwise let a transient hand-built tuple collide -# with a stale entry. +# id(tuple) -> (tuple, fully hydrated Schema). A component is written here only once +# its ENTIRE connected graph is built: a cross-referenced sibling that finishes its +# own populate loop first is still held out of _cache until the outermost hydrate +# frame returns, so a reader (including another thread) never reaches a node whose +# members point at a half-built sibling. The value keeps a reference to the keyed +# tuple so its id() can't be recycled onto a different tuple while cached -- which +# would otherwise let a transient hand-built tuple collide with a stale entry. _cache: dict[int, tuple["StaticSchema", Schema]] = {} -# Per-thread id(tuple) -> in-progress Schema, holding schemas mid-hydration so a -# recursive member target that resolves back to the same tuple gets the in-progress -# object instead of recursing forever. Thread-local so one thread never observes -# another's half-built schema. +# Per-thread id(tuple) -> (tuple, in-progress Schema) for every node of the component +# the outermost hydrate frame is currently building. Serves cycle breaking (a +# recursive target resolving back to a node in flight gets the in-progress object +# instead of recursing forever) and, at the root frame, the publish set. Thread-local +# so one thread never observes another's half-built graph; the root frame clears it. _building = threading.local() # ShapeType ints whose tuples carry a trailing (member_names, member_targets) pair. @@ -173,13 +175,34 @@ def hydrate(data: "StaticSchema | Schema") -> Schema: if cached is not None: return cached[1] - stack: dict[int, Schema] | None = getattr(_building, "stack", None) + stack: dict[int, tuple[StaticSchema, Schema]] | None = getattr( + _building, "stack", None + ) + is_root = stack is None if stack is None: stack = _building.stack = {} building = stack.get(key) if building is not None: - return building + return building[1] + try: + schema = _build(data, key, stack) + if is_root: + # The whole component is now built; publish it atomically. A concurrent + # thread that missed the cache rebuilds its own complete copy rather than + # ever seeing a node from this half-built graph. + _cache.update(stack) + return schema + finally: + if is_root: + _building.stack = None + + +def _build( + data: "StaticSchema", + key: int, + stack: dict[int, tuple["StaticSchema", Schema]], +) -> Schema: type_int = cast(int, data[0]) namespace = cast(str, data[1]) shape_name = cast(str, data[2]) @@ -188,35 +211,31 @@ def hydrate(data: "StaticSchema | Schema") -> Schema: id_ = ShapeID.from_parts(namespace=namespace, name=shape_name) schema = Schema(id=id_, shape_type=shape_type, traits=_expand_traits(traits)) - # Expose the in-progress schema for cycle breaking, but only to this thread and - # only until it is fully populated -- never in _cache until complete. - stack[key] = schema - try: - if type_int in _MEMBER_SHAPE_TYPES and len(data) > 4: - member_names = cast(tuple[str, ...], data[4]) - member_targets = cast( - tuple[tuple[StaticSchemaRef, StaticSchemaTraits], ...], data[5] + # Expose the in-progress schema for cycle breaking before populating members. It + # stays in the thread-local stack (never _cache) until the root frame publishes + # the whole component; a raise mid-populate discards the stack unpublished. + stack[key] = (data, schema) + if type_int in _MEMBER_SHAPE_TYPES and len(data) > 4: + member_names = cast(tuple[str, ...], data[4]) + member_targets = cast( + tuple[tuple[StaticSchemaRef, StaticSchemaTraits], ...], data[5] + ) + # Mutate the members dict in place so a recursive target that captured it + # by reference during the cycle break observes the full map. + members = schema.members + for index, mname in enumerate(member_names): + target_ref, member_traits = member_targets[index] + target = _resolve(target_ref) + resolved = target.traits.copy() + resolved.update(_expand_traits(member_traits)) + members[mname] = Schema( + id=id_.with_member(mname), + shape_type=target.shape_type, + traits=resolved, + members=target.members, + member_target=target, + member_index=index, ) - # Mutate the members dict in place so a recursive target that captured it - # by reference during the cycle break observes the full map. - members = schema.members - for index, mname in enumerate(member_names): - target_ref, member_traits = member_targets[index] - target = _resolve(target_ref) - resolved = target.traits.copy() - resolved.update(_expand_traits(member_traits)) - members[mname] = Schema( - id=id_.with_member(mname), - shape_type=target.shape_type, - traits=resolved, - members=target.members, - member_target=target, - member_index=index, - ) - finally: - del stack[key] - - _cache[key] = (data, schema) return schema diff --git a/packages/smithy-core/tests/unit/test_schema_compact.py b/packages/smithy-core/tests/unit/test_schema_compact.py index ed379a818..3615b9ada 100644 --- a/packages/smithy-core/tests/unit/test_schema_compact.py +++ b/packages/smithy-core/tests/unit/test_schema_compact.py @@ -133,6 +133,49 @@ def test_cache_pins_keyed_tuple_against_id_recycling() -> None: assert _schema_compact._cache[id(tup)][0] is tup +def test_cycle_node_not_published_until_root_completes() -> None: + # In an A -> B -> A cycle, B finishes its own populate loop before A does. B must + # not land in _cache while A (reachable from B) is still half-built: nothing from + # the component is published until the outermost hydrate frame returns. + snapshots: list[tuple[bool, bool]] = [] + + a: StaticSchema = ( + ShapeType.STRUCTURE.value, + NS, + "A", + 0, + ("b",), + ((lambda: b, 0),), + ) + + def to_a() -> object: + # Resolved while B populates, i.e. after B's schema exists but before the + # root (A) frame returns. Record whether either node has leaked into _cache. + snapshots.append( + (id(a) in _schema_compact._cache, id(b) in _schema_compact._cache) + ) + return a + + b: StaticSchema = ( + ShapeType.STRUCTURE.value, + NS, + "B", + 0, + ("a",), + ((to_a, 0),), + ) + + schema_a = hydrate(a) + # The probe ran mid-build and saw neither node cached. + assert snapshots == [(False, False)] + # After the root returns, the whole component is published and fully linked. + assert id(a) in _schema_compact._cache + assert id(b) in _schema_compact._cache + schema_b = schema_a.members["b"].member_target + assert schema_b is not None + assert schema_b.members["a"].member_target is schema_a + + def test_concurrent_hydration_returns_fully_populated_schema() -> None: tup = _struct( "Concurrent",