def com_amazonaws_dynamodb_QueryInput()

in ComAmazonawsDynamodb/runtimes/python/src/aws_cryptography_internal_dynamodb/smithygenerated/com_amazonaws_dynamodb/dafny_to_aws_sdk.py [0:0]

• 96 lines of code
• 35 McCabe index (conditional complexity)

def com_amazonaws_dynamodb_QueryInput(dafny_input):
    output = {}
    output["TableName"] = b"".join(
        ord(c).to_bytes(2, "big") for c in dafny_input.TableName
    ).decode("utf-16-be")
    if dafny_input.IndexName.is_Some:
        output["IndexName"] = b"".join(
            ord(c).to_bytes(2, "big") for c in dafny_input.IndexName.value
        ).decode("utf-16-be")

    if dafny_input.Select.is_Some:
        output["Select"] = (
            aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Select(
                dafny_input.Select.value
            )
        )

    if dafny_input.AttributesToGet.is_Some:
        output["AttributesToGet"] = [
            b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode(
                "utf-16-be"
            )
            for list_element in dafny_input.AttributesToGet.value
        ]

    if dafny_input.Limit.is_Some:
        output["Limit"] = dafny_input.Limit.value

    if dafny_input.ConsistentRead.is_Some:
        output["ConsistentRead"] = dafny_input.ConsistentRead.value

    if dafny_input.KeyConditions.is_Some:
        output["KeyConditions"] = {
            b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
                "utf-16-be"
            ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Condition(
                value
            )
            for (key, value) in dafny_input.KeyConditions.value.items
        }

    if dafny_input.QueryFilter.is_Some:
        output["QueryFilter"] = {
            b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
                "utf-16-be"
            ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_Condition(
                value
            )
            for (key, value) in dafny_input.QueryFilter.value.items
        }

    if dafny_input.ConditionalOperator.is_Some:
        output["ConditionalOperator"] = (
            aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ConditionalOperator(
                dafny_input.ConditionalOperator.value
            )
        )

    if dafny_input.ScanIndexForward.is_Some:
        output["ScanIndexForward"] = dafny_input.ScanIndexForward.value

    if dafny_input.ExclusiveStartKey.is_Some:
        output["ExclusiveStartKey"] = {
            b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
                "utf-16-be"
            ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
                value
            )
            for (key, value) in dafny_input.ExclusiveStartKey.value.items
        }

    if dafny_input.ReturnConsumedCapacity.is_Some:
        output["ReturnConsumedCapacity"] = (
            aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_ReturnConsumedCapacity(
                dafny_input.ReturnConsumedCapacity.value
            )
        )

    if dafny_input.ProjectionExpression.is_Some:
        output["ProjectionExpression"] = b"".join(
            ord(c).to_bytes(2, "big") for c in dafny_input.ProjectionExpression.value
        ).decode("utf-16-be")

    if dafny_input.FilterExpression.is_Some:
        output["FilterExpression"] = b"".join(
            ord(c).to_bytes(2, "big") for c in dafny_input.FilterExpression.value
        ).decode("utf-16-be")

    if dafny_input.KeyConditionExpression.is_Some:
        output["KeyConditionExpression"] = b"".join(
            ord(c).to_bytes(2, "big") for c in dafny_input.KeyConditionExpression.value
        ).decode("utf-16-be")

    if dafny_input.ExpressionAttributeNames.is_Some:
        output["ExpressionAttributeNames"] = {
            b"".join(ord(c).to_bytes(2, "big") for c in key)
            .decode("utf-16-be"): b"".join(ord(c).to_bytes(2, "big") for c in value)
            .decode("utf-16-be")
            for (key, value) in dafny_input.ExpressionAttributeNames.value.items
        }

    if dafny_input.ExpressionAttributeValues.is_Some:
        output["ExpressionAttributeValues"] = {
            b"".join(ord(c).to_bytes(2, "big") for c in key).decode(
                "utf-16-be"
            ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.dafny_to_aws_sdk.com_amazonaws_dynamodb_AttributeValue(
                value
            )
            for (key, value) in dafny_input.ExpressionAttributeValues.value.items
        }

    return output