Refactored BaseDict class.

Author: fabiocaccamo

benedict/dicts/base/base_dict.py

@@ -3,85 +3,116 @@
 
 class BaseDict(dict):
 
-    _dict = {}
+    _dict = None
 
     def __init__(self, *args, **kwargs):
         if len(args) == 1 and isinstance(args[0], dict):
             self._dict = args[0]
-        else:
-            self._dict = dict(*args, **kwargs)
-        super(BaseDict, self).__init__(self._dict)
-
-    def __bool__(self):
-        return bool(self._dict)
+            super(BaseDict, self).__init__(self._dict)
+            return
+        self._dict = None
+        super(BaseDict, self).__init__(*args, **kwargs)
 
     def __contains__(self, key):
-        return key in self._dict
+        if self._dict is not None:
+            return key in self._dict
+        return super(BaseDict, self).__contains__(key)
 
     def __delitem__(self, key):
-        del self._dict[key]
+        if self._dict is not None:
+            del self._dict[key]
+            return
         super(BaseDict, self).__delitem__(key)
 
     def __eq__(self, other):
-        return self._dict == other
+        if self._dict is not None:
+            return self._dict == other
+        return super(BaseDict, self).__eq__(other)
 
     def __getitem__(self, key):
-        return self._dict[key]
+        if self._dict is not None:
+            return self._dict[key]
+        return super(BaseDict, self).__getitem__(key)
 
     def __iter__(self):
-        return iter(self._dict)
+        if self._dict is not None:
+            return iter(self._dict)
+        return super(BaseDict, self).__iter__()
 
     def __len__(self):
-        return len(self._dict)
-
-    def __nonzero__(self):
-        return bool(self._dict)
+        if self._dict is not None:
+            return len(self._dict)
+        return super(BaseDict, self).__len__()
 
     def __repr__(self):
-        return repr(self._dict)
+        if self._dict is not None:
+            return repr(self._dict)
+        return super(BaseDict, self).__repr__()
 
     def __setitem__(self, key, value):
-        self._dict[key] = value
+        if self._dict is not None:
+            self._dict[key] = value
+            return
         super(BaseDict, self).__setitem__(key, value)
 
     def __str__(self):
-        return str(self._dict)
+        if self._dict is not None:
+            return str(self._dict)
+        return super(BaseDict, self).__str__()
 
     def __unicode__(self):
-        return unicode(self._dict)
+        if self._dict is not None:
+            return unicode(self._dict)
+        return super(BaseDict, self).__unicode__()
 
     def clear(self):
-        self._dict.clear()
+        if self._dict is not None:
+            self._dict.clear()
+            return
         super(BaseDict, self).clear()
 
     def copy(self):
-        return self._dict.copy()
+        if self._dict is not None:
+            return self._dict.copy()
+        return super(BaseDict, self).copy()
 
     def dict(self):
-        return self._dict
+        if self._dict is not None:
+            return self._dict
+        return self
 
     def get(self, key, default=None):
-        return self._dict.get(key, default)
+        if self._dict is not None:
+            return self._dict.get(key, default)
+        return super(BaseDict, self).get(key, default)
 
     def items(self):
-        return self._dict.items()
+        if self._dict is not None:
+            return self._dict.items()
+        return super(BaseDict, self).items()
 
     def keys(self):
-        return self._dict.keys()
+        if self._dict is not None:
+            return self._dict.keys()
+        return super(BaseDict, self).keys()
 
     def pop(self, key, *args):
-        value = self._dict.pop(key, *args)
-        super(BaseDict, self).pop(key, None)
-        return value
+        if self._dict is not None:
+            return self._dict.pop(key, *args)
+        return super(BaseDict, self).pop(key, *args)
 
     def setdefault(self, key, default=None):
-        value = self._dict.setdefault(key, default)
-        super(BaseDict, self).setdefault(key, default)
-        return value
+        if self._dict is not None:
+            return self._dict.setdefault(key, default)
+        return super(BaseDict, self).setdefault(key, default)
 
     def update(self, other):
-        self._dict.update(other)
+        if self._dict is not None:
+            self._dict.update(other)
+            return
         super(BaseDict, self).update(other)
 
     def values(self):
-        return self._dict.values()
+        if self._dict is not None:
+            return self._dict.values()
+        return super(BaseDict, self).values()