def unflatten(dictionary):
    resultDict = dict()
    for key, value in dictionary.items():
        parts = key.split(".")
        d = resultDict
        for part in parts[:-1]:
            if part not in d:
                d[part] = dict()
            d = d[part]
        d[parts[-1]] = value
    return resultDict

You can do it with loop. Is it what you want following?

my_dict = {'435': ['188', '436', '439', '1038'], '188': ['198'], '436': ['86', '115', '437', '444', '626', '650'], '439': [], '1038': ['733', '1037'], '198': [], '86': [], '115': [], '437': [], '444': [], '626': [], '650': [], '733': ['14'], '1037': [], '14': []}

table = {}
roots = set(my_dict)
for name, children in my_dict.items():
    table.setdefault(name, {'name': name})
    if children:
        table[name]['children'] = [
            table.setdefault(child, {'name': child})
            for child in children
        ]
        roots -= set(children)
result = {k: v for k, v in table.items() if k in roots}
print(list(result.values()))

output:

[{'name': '435', 'children': [{'name': '188', 'children': [{'name': '198'}]}, {'name': '436', 'children': [{'name': '86'}, {'name': '115'}, {'name': '437'}, {'name': '444'}, {'name': '626'}, {'name': '650'}]}, {'name': '439'}, {'name': '1038', 'children': [{'name': '733', 'children': [{'name': '14'}]}, {'name': '1037'}]}]}]

explanation:

• table holds all items(name and children data).
• If an item has children, register them to table by dict.setdefault.
• roots contains all items that doen't belong any other items.
• At last, filter only items which are in roots.

Here is a solution using a tree of dict:

import collections

def tree():
    return collections.defaultdict(tree)


def unflatten(pair_list):
    root = tree()
    for mount, path in pair_list:
        parts = mount.split(":")
        curr = root
        for part in parts[:-1]:
            index = int(part[1:-1]) if part[0] == "[" else part
            curr = curr[index]
        part = parts[-1]
        index = int(part[1:-1]) if part[0] == "[" else part
        curr[index] = path
    return root

With the following input:

pair_list = [
  ['mounts:device', '/dev/sda3'],
  ['mounts:fstype:[0]', 'ext1'],
  ['mounts:fstype:[1]', 'ext3'],
  ['mounts:test:lala:fstype:[0]:[0]', 'abc']
]

You'll get:

{
    "mounts": {
        "fstype": {
            "0": "ext1",
            "1": "ext3"
        },
        "test": {
            "lala": {
                "fstype": {
                    "0": {
                        "0": "abc"
                    }
                }
            }
        },
        "device": "/dev/sda3"
    }
}

Then you can use the recursive function make_listbellow to turn the integer indexes in a list.

def make_list(root):
    if isinstance(root, str):
        return root
    keys = list(root.keys())
    if all(isinstance(k, int) for k in keys):
        values = [None] * (max(keys) + 1)
        for k in keys:
            values[k] = make_list(root[k])
        return values
    else:
        return {k: make_list(v) for k, v in root.items()}

Here is the result with the pair_list:

flat = unflatten(pair_list)
flat = make_list(flat)

You'll get:

{'mounts': {'device': '/dev/sda3',
            'fstype': ['ext1', 'ext3'],
            'test': {'lala': {'fstype': [['abc']]}}}}

Is it fine?

Using a defaultdict saves you a lot of hassle having to conditionally set up the structure of the dictionary:

>>> signals = [{"bus":"BUS_A", "message":"MSG_1", "fieldname":"Signal1"},
...            {"bus":"BUS_A", "message":"MSG_1", "fieldname":"Signal2"},
...            {"bus":"BUS_B", "message":"MSG_2", "fieldname":"Signal3"},
...            {"bus":"BUS_B", "message":"MSG_2", "fieldname":"Signal4"}]
>>> from collections import defaultdict
>>> buses = defaultdict(lambda: defaultdict(dict))
>>> for s in signals:
...     buses[s["bus"]][s["message"]][s["fieldname"]] = None
...
>>> buses
defaultdict(<function <lambda> at 0x00000265E25451F0>, {'BUS_A': defaultdict(<class 'dict'>, {'MSG_1': {'Signal1': None, 'Signal2': None}}), 'BUS_B': defaultdict(<class 'dict'>, {'MSG_2': {'Signal3': None, 'Signal4': None}})})

Without defaultdict you need to initialize each value to an empty dictionary as needed:

>>> buses = {}
>>> buses = {}
>>> for s in signals:
...     if s["bus"] not in buses:
...         buses[s["bus"]] = {}
...     if s["message"] not in buses[s["bus"]]:
...         buses[s["bus"]][s["message"]] = {}
...     buses[s["bus"]][s["message"]][s["fieldname"]] = None
...
>>> buses
{'BUS_A': {'MSG_1': {'Signal1': None, 'Signal2': None}}, 'BUS_B': {'MSG_2': {'Signal3': None, 'Signal4': None}}}