I couldn't find anything out in the wild. So, I decided to port the PHP implementation of dynamodb json to standard json that was published here. I tested this in a python lambda function processing DynamoDB stream. If there is a better way to do this, please let me know.

(PS: This is not a complete port of PHP Marshaler)

The JSON in the question gets transformed to:

{  
   "feas":{  
      "fea":[  
         {  
            "pre":"1",
            "Mo":"1",
            "Ti":"20160618184156529",
            "Fa":"0",
            "Li":"1",
            "Fr":"4088682"
         }
      ]
   }
}

def unmarshalJson(node):
    data = {}
    data["M"] = node
    return unmarshalValue(data, True)


def unmarshalValue(node, mapAsObject):
    for key, value in node.items():
        if(key == "S" or key == "N"):
            return value
        if(key == "M" or key == "L"):
            if(key == "M"):
                if(mapAsObject):
                    data = {}
                    for key1, value1 in value.items():
                        data[key1] = unmarshalValue(value1, mapAsObject)
                    return data
            data = []
            for item in value:
                data.append(unmarshalValue(item, mapAsObject))
            return data

I know this is an old question, but I came across it and the accepted answer didn't help me (it seems to suggest that you can feed boto3 with plain JSON, but it didn't work for me) and the library mentioned in the comments didn't help me either.

What did work for me was using the serializer/deserializer from boto3.dynamodb.types, basically as suggested by this answer on a very similar topic.

from boto3.dynamodb.types import TypeSerializer, TypeDeserializer
import json

serializer = TypeSerializer()
deserializer = TypeDeserializer()


# for building a DynamoDB JSON from a Python object
def serialize(item):
    serialized_item = serializer.serialize(vars(item) if hasattr(item, '__dict__') else item)

    return item if 'M' not in serialized_item else serialized_item['M']


# for building a plain JSON from a DynamoDB JSON
def deserialize(dynamodb_json_string):
    return deserializer.deserialize({'M': dynamodb_json_string})


class MyItem:
    def __init__(self, some_string_value=None, some_numeric_value=None):
        self.my_key = some_string_value
        self.my_other_key = some_numeric_value

    def __str__(self):
        return json.dumps(self, default=lambda x: x.__dict__)


if __name__ == '__main__':
    my_classy_item = MyItem("my_string_value", 5)
    my_string_item = json.loads('{"my_key": "my_string_value", "my_other_key" : 5}')

    print(serialize(my_classy_item))
    print(serialize(my_string_item))

I was able to develop a little code to convert this DynamoDB json into a regular json. I used the dynamodb_json import.

##that one in the question
payload_stack = {...} 

convert_regular_json = json.loads(payload_stack)
print(convert_regular_json)

The output:

{
    'Records': [{
        'eventID': '123456',
        'eventName': 'INSERT',
        'eventVersion': '1.1',
        'eventSource': 'aws:dynamodb',
        'awsRegion': 'sa-east-1',
        'dynamodb': {
            'ApproximateCreationDateTime': 1644956685.0,
            'Keys': {
                'body_field': 1931
            },
            'NewImage': {
                'body_field': 1931,
                'txt_vlr_parm_requ': {
                    'headers': {
                        'Authorization': 'token',
                        'correlationID': '987654321'
                    },
                    'requestContext': {
                        'requestId': '123'
                    },
                    'body': {
                        'avro_schema': '{"type":"record","namespace":"Tutorialspoint","name":"Employee","fields":[{"name":"Name","type":"string"},{"name":"Age","type":"int"}, {"name":"Address","type":"string"}, {"name":"Role","type":"string"} ]}',
                        'cluster': 'events',
                        'sigla': 'ft7',
                        'subject': 'teste-dynamo',
                        'branch': 'development',
                        'id_requisicao': 1818
                    }
                },
                'nom_tabe': 'tabela_teste',
                'cod_situ_psst_ingo': 'NOVO',
                'historic': '{"historico": [{"data/hora": "09-02-22 18:18:41", "status": "NOVO"}]}',
                'nom_arqu_bckt': 'arquivo.avro'
            },
            'SequenceNumber': '87226300000000005691898607',
            'SizeBytes': 1672,
            'StreamViewType': 'NEW_IMAGE'
        },
        'eventSourceARN': 'arn:aws'
    }]
}

And to catch the 'body' field:

catch_body_payload = var['Records'][0].get('dynamodb').get('NewImage').get('txt_vlr_parm_requ').get('body')

@uhiyama The following line of code in your solution can be summarized/simplified using the get() method:

image_url = item['image_url'] if item['image_url'] else None

image_url = item.get("image_url")

I loaded the JSON this way

import boto3
import json

dynamodbclient=boto3.resource('dynamodb')
sample_table = dynamodbclient.Table('ec2metadata')

with open('/samplepath/spotec2interruptionevent.json', 'r') as myfile:
    data=myfile.read()

# parse file
obj = json.loads(data)

#instance_id and cluster_id is the Key in dynamodb table 

    response=sample_table.put_item(
                              Item={
                                  'instance_id': instanceId,
                                  'cluster_id': clusterId,
                                  'event':obj

                              }
                              )

import boto3
import json
import decimal
from boto3.dynamodb.conditions import Key, Attr

# Helper class to convert a DynamoDB item to JSON.
class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, decimal.Decimal):
            return str(o)
        if isinstance(o, set):  #<---resolving sets as lists
            return list(o)
        return super(DecimalEncoder, self).default(o)


dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('mytable')

response = table.query(
    KeyConditionExpression=Key('object_type').eq("employee")
)

print(json.dumps((response), indent=4, cls=DecimalEncoder))