Autocompletion for keys in VSCode etc

[s-github-2]

The following subclassing worked in VScode notebook . Is it possible to enhance benedict to just do this built-in to support tab completion?
Maybe some keys would have to be converted to replace spaces with underscores etc (not done below)
Also if any subdicts could also be converted automatically to benedict so tab completion can work on nested dictionaries.

from benedict import Benedict

class AutoCompleteBenedict(Benedict):
    def __dir__(self):
        # grab the normal attributes…
        attrs = super().__dir__()
        try:
            # …and add your dynamic keys
            attrs.extend(self.keys())
        except Exception:
            pass
        return list(dict.fromkeys(attrs))  # dedupe, preserve order

# usage
mydict = AutoCompleteBenedict({'foo': 1, 'bar': 2})
# now in IPython / VSCode REPL, typing “mydict.<TAB>” will show foo, bar, etc.

[s-github-2]

Here is an updated version of the code I am using for tab completion in VSCode with benedict

class AutoCompleteBenedict(benedict):
    """
    A Benedict subclass that:
     - Recursively converts all nested dicts into AutoCompleteBenedict
     - Replaces spaces in keys with underscores at every level
     - Adds its keys to __dir__ and IPython key-completions
     nested dicts need type hints to be recognized by IDEs for autocompletion.
    Usage:
    new_dict= AutoCompleteBenedict({
        'key with space': {'nested key': 'nested_key_value'},
    })
    # now you can access it like a normal dict, but with autocompletion:
    print(new_dict['key_with_space']['nested_key'])  # outputs 'value'
    You can also use it in IPython/Jupyter notebooks for tab-completion:
    new_dict.<TAB>  # will show 'key_with_space' as an option
  # nested dicts need type hints to show nested keys so require declaration as follows
    nested: AutoCompleteBenedict = new_dict.key_with_space
    # now you can access it like a normal dict, but with autocompletion:
 
    nested.nested_key  # outputs 'nested_key_value' and all keys at this level can be viewed via tab completion
    Note: VSCode notebook tab completion works in the next cell not the same cell 
      after executing the cell with the AutoCompleteBenedict instance.
    """
    # restore the built-in dict repr so pprint works the same on this subclass as the dict class
    __repr__ = dict.__repr__

    def __init__(self, *args, **kwargs):
        # initialize as normal dict
        super().__init__(*args, **kwargs)
        # then convert any nested dicts/lists in place
        self._convert_nested()

    def _convert_nested(self):
        for key in list(self.keys()):
            value = self[key]
            # normalize key
            new_key = key.replace(' ', '_')
            if new_key != key:
                # re-assign under new key, delete old
                super().__setitem__(new_key, value)
                super().__delitem__(key)
                key = new_key
                value = self[key]

            # if it’s a dict, wrap it
            if isinstance(value, dict) and not isinstance(value, AutoCompleteBenedict):
                super().__setitem__(key, AutoCompleteBenedict(value))

        # if it’s a list, map any dict items
        elif isinstance(value, list):
            wrapped = [
                AutoCompleteBenedict(item) if isinstance(item, dict) else item
                for item in value
            ]
            super().__setitem__(key, wrapped)

def __dir__(self):
    # include both standard attributes and our dynamic keys
    return sorted(set(super().__dir__() + list(self.keys())))

def _ipython_key_completions_(self):
    # IPython/Jupyter will call this for tab-completion in subscripts
    return list(self.keys())