How do I compare json_key_dots with json_key_brackets?

Question

I have two files to compare and insert into second file missing key_value or update existing key with new value. the problem for me is that first file has dots to separate keys:

{"a.b.c":0}

second file looks like:

{"a":{"b":{"c":0}}}

Answer 1

I recently had to deal with something similar. This is what I came up with:

def to_flat_dict(d, delim='.'):
    """TLDR;
    While there are entries in the dictionary that have a dict as a value:
        pop them at the outer level and create a delimited path as a key, eg:
            {'a': {'b': {'c': 0}}} -> {'a.b': {'c': 0}}
            # by same process
            {'a.b': {'c': 0}} -> {'a.b.c': 0}
    """
    flat = dict(d)   # work on a copy
    incomplete = list(flat)  
    while(incomplete):
        k = incomplete.pop()
        if isinstance(flat[k], dict):
            val = flat.pop(k)
            for subk, subv in val.items():
                new_key = delim.join((k, subk))
                flat[new_key] = subv
                incomplete.append(new_key)
    return flat


def to_nested_dict(d, delim='.'):
    """TLDR;
    
    flat: {"a.b.c":0}
    # pop 'a.b.c' and value 0 and break key into parts
    parts:  ['a','b','c']:
    
    # process 'a'
    flat <- {'a':dict()} 
    # process 'b'
    flat <- {'a': {'b': dict()}} 
    # process 'c' @ tmp[parts[-1]] = val
    flat <- {'a': {'b': {'c': 0}}} 

    """
    flat = dict(d) # work on a copy
    keys = list(d) # we copy the keys since we are modifying the dict in place
    for key in keys:
        # Basic idea: for all keys that contain the delim
        if delim in key:
            val = flat.pop(key)
            # get the parts (a.b.c -> [a, b, c])
            parts = key.split(delim)
            # we start with the outer dict, but as we process parts of the key
            level = flat # we assign level to the newly created deeper dicts
            for part in parts[:-1]:
                if part not in level:   # if the part isn't a key at this depth
                    level[part] = dict() # create a new dict to fill
                level = level[part]      # and work on the next deeper level
            level[parts[-1]] = val # when we get to the "leaf" set it as val
    return flat

You can get your desired nested dict by calling:

to_nested_dict({'a.b.c':0})

You can invert this with to_flat_dict:

to_flat_dict(to_nested_dict({'a.b.c':0})) # back to {'a.b.c':0}

Your mileage may vary!

Answer 2

I wrote code that works for me but I hate it, especially ff_function. I think it should be done using recursive function- don't know how to :(

>>> def ff(k, d, i, v):
...   if i == len(k)-1:
...     last_value = v 
...   else:
...     last_value = {}
...   if i == 0:
...     d[k[0]] = last_value
...   elif i == 1:
...     d[k[0]][k[1]] = last_value
...   elif i == 2:
...     d[k[0]][k[1]][k[2]] = last_value
...   elif i == 3:
...     d[k[0]][k[1]][k[2]][k[3]] = last_value
...   elif i == 4:
...     d[k[0]][k[1]][k[2]][k[3]][k[4]] = last_value
...   elif i == 5:
...     d[k[0]][k[1]][k[2]][k[3]][k[4]][k[5]] = last_value
...   return d
... 
>>> 
>>> 
>>> def f(k, v):
...   td = {}
...   keys = k.split('.')
...   for i in range(len(keys)):
...     td = ff(keys, td, i, v)
...   return td
... 
>>> 
>>> f('a.b.c.d', ['some', 'values', 'here'])
{'a': {'b': {'c': {'d': ['some', 'values', 'here']}}}}
>>> f('a', 0)
{'a': 0}