| import copy
|
|
|
|
|
| class Dict(dict):
|
|
|
| def __init__(__self, *args, **kwargs):
|
| object.__setattr__(__self, '__parent', kwargs.pop('__parent', None))
|
| object.__setattr__(__self, '__key', kwargs.pop('__key', None))
|
| object.__setattr__(__self, '__frozen', False)
|
| for arg in args:
|
| if not arg:
|
| continue
|
| elif isinstance(arg, dict):
|
| for key, val in arg.items():
|
| __self[key] = __self._hook(val)
|
| elif isinstance(arg, tuple) and (not isinstance(arg[0], tuple)):
|
| __self[arg[0]] = __self._hook(arg[1])
|
| else:
|
| for key, val in iter(arg):
|
| __self[key] = __self._hook(val)
|
|
|
| for key, val in kwargs.items():
|
| __self[key] = __self._hook(val)
|
|
|
| def __setattr__(self, name, value):
|
| if hasattr(self.__class__, name):
|
| raise AttributeError("'Dict' object attribute "
|
| "'{0}' is read-only".format(name))
|
| else:
|
| self[name] = value
|
|
|
| def __setitem__(self, name, value):
|
| isFrozen = (hasattr(self, '__frozen') and
|
| object.__getattribute__(self, '__frozen'))
|
| if isFrozen and name not in super(Dict, self).keys():
|
| raise KeyError(name)
|
| super(Dict, self).__setitem__(name, value)
|
| try:
|
| p = object.__getattribute__(self, '__parent')
|
| key = object.__getattribute__(self, '__key')
|
| except AttributeError:
|
| p = None
|
| key = None
|
| if p is not None:
|
| p[key] = self
|
| object.__delattr__(self, '__parent')
|
| object.__delattr__(self, '__key')
|
|
|
| def __add__(self, other):
|
| if not self.keys():
|
| return other
|
| else:
|
| self_type = type(self).__name__
|
| other_type = type(other).__name__
|
| msg = "unsupported operand type(s) for +: '{}' and '{}'"
|
| raise TypeError(msg.format(self_type, other_type))
|
|
|
| @classmethod
|
| def _hook(cls, item):
|
| if isinstance(item, dict):
|
| return cls(item)
|
| elif isinstance(item, (list, tuple)):
|
| return type(item)(cls._hook(elem) for elem in item)
|
| return item
|
|
|
| def __getattr__(self, item):
|
| return self.__getitem__(item)
|
|
|
| def __missing__(self, name):
|
| if object.__getattribute__(self, '__frozen'):
|
| raise KeyError(name)
|
| return self.__class__(__parent=self, __key=name)
|
|
|
| def __delattr__(self, name):
|
| del self[name]
|
|
|
| def to_dict(self):
|
| base = {}
|
| for key, value in self.items():
|
| if isinstance(value, type(self)):
|
| base[key] = value.to_dict()
|
| elif isinstance(value, (list, tuple)):
|
| base[key] = type(value)(
|
| item.to_dict() if isinstance(item, type(self)) else
|
| item for item in value)
|
| else:
|
| base[key] = value
|
| return base
|
|
|
| def copy(self):
|
| return copy.copy(self)
|
|
|
| def deepcopy(self):
|
| return copy.deepcopy(self)
|
|
|
| def __deepcopy__(self, memo):
|
| other = self.__class__()
|
| memo[id(self)] = other
|
| for key, value in self.items():
|
| other[copy.deepcopy(key, memo)] = copy.deepcopy(value, memo)
|
| return other
|
|
|
| def update(self, *args, **kwargs):
|
| other = {}
|
| if args:
|
| if len(args) > 1:
|
| raise TypeError()
|
| other.update(args[0])
|
| other.update(kwargs)
|
| for k, v in other.items():
|
| if ((k not in self) or
|
| (not isinstance(self[k], dict)) or
|
| (not isinstance(v, dict))):
|
| self[k] = v
|
| else:
|
| self[k].update(v)
|
|
|
| def __getnewargs__(self):
|
| return tuple(self.items())
|
|
|
| def __getstate__(self):
|
| return self
|
|
|
| def __setstate__(self, state):
|
| self.update(state)
|
|
|
| def __or__(self, other):
|
| if not isinstance(other, (Dict, dict)):
|
| return NotImplemented
|
| new = Dict(self)
|
| new.update(other)
|
| return new
|
|
|
| def __ror__(self, other):
|
| if not isinstance(other, (Dict, dict)):
|
| return NotImplemented
|
| new = Dict(other)
|
| new.update(self)
|
| return new
|
|
|
| def __ior__(self, other):
|
| self.update(other)
|
| return self
|
|
|
| def setdefault(self, key, default=None):
|
| if key in self:
|
| return self[key]
|
| else:
|
| self[key] = default
|
| return default
|
|
|
| def freeze(self, shouldFreeze=True):
|
| object.__setattr__(self, '__frozen', shouldFreeze)
|
| for key, val in self.items():
|
| if isinstance(val, Dict):
|
| val.freeze(shouldFreeze)
|
|
|
| def unfreeze(self):
|
| self.freeze(False)
|
|
|
