Simplify dictionary in python from a Firestore Trigger Event

Question

I'm reading data from an Update Cloud Firestore Trigger. The event is a dictionary that contains the data whithin the key ['value']['fields']. However, each of the keys contains s nested dictionary containing a key like 'integerValue', 'booleanValue' or 'stringValue', where the value of integerValue is actually a string. Is there a method to remove the 'type pointers'?

How can I convert this:

{
    'fields': {
        'count': {
            'integerValue': '0'
        },
        'verified': {
            'booleanValue': False
        },
        'user': {
            'stringValue': 'Matt'
        }
    }
}

To this:

{
    'count': 0,
    'verified': False,
    'user': 'Matt',
}

Answer 1

You can create a mapping of the known types and convert the values that way:

types = {
    'integerValue': int,
    'booleanValue': bool,
    'stringValue': str,
}

You can replace a nested dictionary like the one you have through the magic of dict.popitem:

replacement = {}
for key, meta in event['value']['fields'].items():
    typ, value = meta.popitem()
    replacement[key] = types[typ](value)
event['value'] = replacement

You can reduce it to a one liner with a dictionary comprehension:

event['value'] = {k: types[t](v) for k t, v in (k, *d.popitem()) for k, d in event['value']['fields'].items())}

Answer 2

Recently i encountered similar problem.

We could recursively traverse the map to extract and simplify the event trigger data.

Here's python implementation, extended from previous answers.

class FirestoreTriggerConverter(object):
    def __init__(self, client=None) -> None:
        self.client = client if client else firestore.client()
        self._action_dict = {
        'geoPointValue': (lambda x: dict(x)),
        'stringValue': (lambda x: str(x)),
        'arrayValue': (lambda x: [self._parse_value(value_dict) for value_dict in x.get("values", [])]),
        'booleanValue': (lambda x: bool(x)),
        'nullValue': (lambda x: None),
        'timestampValue': (lambda x: self._parse_timestamp(x)),
        'referenceValue': (lambda x: self._parse_doc_ref(x)),
        'mapValue': (lambda x: {key: self._parse_value(value) for key, value in x["fields"].items()}),
        'integerValue': (lambda x: int(x)),
        'doubleValue': (lambda x: float(x)),
    }

def convert(self, data_dict: dict) -> dict:
    result_dict = {}
    for key, value_dict in data_dict.items():
        result_dict[key] = self._parse_value(value_dict)
    return result_dict

def _parse_value(self, value_dict: dict) -> Any:
    data_type, value = value_dict.popitem()

    return self._action_dict[data_type](value)

def _parse_timestamp(self, timestamp: str):
    try:
        return datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%S.%fZ')
    except ValueError as e:
        return datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%SZ')

def _parse_doc_ref(self, doc_ref: str) -> DocumentReference:
    path_parts = doc_ref.split('/documents/')[1].split('/')
    collection_path = path_parts[0]
    document_path = '/'.join(path_parts[1:])

    doc_ref = self.client.collection(collection_path).document(document_path)
    return doc_ref

Use this as follows

converter = FirestoreTriggerConverter(client)
simplified_data_dict = converter.convert(event_data_dict["event"]["value"]["fields"])

Answer 3

Use keys() in dictionary

origin_dict={
    'fields': {
        'count': {
            'integerValue': '0'
        },
        'verified': {
            'booleanValue': False
        },
        'user': {
            'stringValue': 'Matt'
        }
    }
}
# remove first layer
b = origin_dict['fields']
new_dict = dict()

for i in b.keys():
    # i will be second layer of dictionary
    for j in b[i].keys():
        # j will be third layer of dictionary
        new_dict[i] = b[i][j]
print (new_dict)

Answer 4

There is no explicit method to do so. One you can do is iterate through existing dictionary picking up items you need in the new dictionary:

d = {
    'fields': {
        'count': {
            'integerValue': '0'
        },
        'verified': {
            'booleanValue': False
        },
        'user': {
            'stringValue': 'Matt'
        }
    }
}

required = ['count', 'verified', 'user']
d1 = {}
for x in d.values():
    for y in required:
        if 'integerValue' in x[y].keys():
            d1[y] = int(list(x[y].values())[0])
        else:
            d1[y] = list(x[y].values())[0]

print(d1)
# {'count': 0, 'verified': False, 'user': 'Matt'}