edict: load JSON into Python object but access with .dot notation

edict.py

class edict(dict):  # Similar to bunch, but less, and JSON-centric
    # based on class dotdict(dict):  # from http://stackoverflow.com/questions/224026/dot-notation-for-dictionary-keys
    
    __setattr__= dict.__setitem__  # TBD: support assignment of nested dicts by overriding this?
    __delattr__= dict.__delitem__

    def __init__(self, data):
        if type(data) in ( unicode, str ):
            data = json.loads( data)
    
        for name, value in data.iteritems():
            setattr(self, name, self._wrap(value))

    def __getattr__(self, attr):
        return self.get(attr, None)

    def _wrap(self, value):  # from class Struct by XEye '11 http://stackoverflow.com/questions/1305532/convert-python-dict-to-object
        if isinstance(value, (tuple, list, set, frozenset)):
            return type(value)([self._wrap(v) for v in value])  # recursion!
        else:
            if isinstance(value, dict):
                return edict(value)  # is there a relative way to get class name?
            else:
                return value

# optional handy member function(s): pretty-printer, ... left as an exercise for the reader...
# def subset(self, only_keys=[], exclude_keys=[], as='json', indent=2, separators=(',',':')):

# EOF

@caffeinatedMike This code snippet looks good, but what if you want to add ability if value is None: return default_value
I am new in python and do not know other solution, my modification:

class JsonOptions(dict):
    __setattr__ = dict.__setitem__
    __delattr__ = dict.__delitem__

    def __init__(self, payload):
        super().__init__()

        if isinstance(payload, str):
            payload = json.loads(payload)

        for name, value in payload.items():
            setattr(self, name, self._wrap(value))

    def __getattr__(self, attr: str):
        return self.attr(attr)

    def _wrap(self, value):
        if self._is_indexable(value):
            # (!) recursive (!)
            return type(value)([self._wrap(v) for v in value])
        elif isinstance(value, dict):
            return JsonOptions(value)
        else:
            return value

    def attr(self, attr: str, default=None):
        def _traverse(o, name):
            if o is None:
                return None

            if self._is_indexable(o):
                try:
                    return o[int(name)]
                except (IndexError, ValueError):
                    return None
            elif isinstance(o, dict):
                return o.get(name, None)
            else:
                return None

        if '.' in attr:
            value = reduce(_traverse, attr.split('.'), self)
        else:
            value = self.get(attr, None)

        return default if value is None else value

    @staticmethod
    def _is_indexable(o):
        return isinstance(o, (tuple, list, set, frozenset))

P.S. is there a more nice solution