-

cool-RR · cool-RR · commit 0883e3995ae8 · 2014-10-08T17:24:40.000+03:00
diff --git a/misc/IDE files/Wing/python_toolbox_py3.wpr b/misc/IDE files/Wing/python_toolbox_py3.wpr
@@ -16,10 +16,10 @@ debug.launch-configs = (1,
          'pypath': ('default',
                     ''),
          'pyrunargs': ('project',
-                       ''),
-         'runargs': u'--processes=3',
-         'rundir': ('custom',
-                    u'${WING:PROJECT_HOME}')})})
+                       u''),
+         'runargs': u'',
+         'rundir': ('default',
+                    u'')})})
 proj.directory-list = [{'dirloc': loc('../../..'),
                         'excludes': [u'dist',
                                      u'source_py2',
diff --git a/source_py3/python_toolbox/nifty_collections/bagging.py b/source_py3/python_toolbox/nifty_collections/bagging.py
@@ -13,7 +13,7 @@
 from .lazy_tuple import LazyTuple
 from .ordered_dict import OrderedDict
 from .frozen_dict_and_frozen_ordered_dict import FrozenDict, FrozenOrderedDict
-from .abstract import Ordered
+from .abstract import Ordered, DefinitelyUnordered
 
 try:                                    # Load C helper function if available
     from _collections import _count_elements
@@ -363,43 +363,43 @@ def __repr__(self):
         )
     
 
-class _OrderedDictDelegator(Ordered, collections.MutableMapping):
+class _BaseDictDelegator(collections.MutableMapping):
 
     # Start by filling-out the abstract methods
     def __init__(self, dict=None, **kwargs):
-        self.data = OrderedDict()
+        self._dict = self._dict_type()
         if dict is not None:
             self.update(dict)
         if len(kwargs):
             self.update(kwargs)
-    def __len__(self): return len(self.data)
+    def __len__(self): return len(self._dict)
     def __getitem__(self, key):
-        if key in self.data:
-            return self.data[key]
+        if key in self._dict:
+            return self._dict[key]
         if hasattr(self.__class__, "__missing__"):
             return self.__class__.__missing__(self, key)
         raise KeyError(key)
-    def __setitem__(self, key, item): self.data[key] = item
-    def __delitem__(self, key): del self.data[key]
+    def __setitem__(self, key, item): self._dict[key] = item
+    def __delitem__(self, key): del self._dict[key]
     def __iter__(self):
-        return iter(self.data)
+        return iter(self._dict)
 
     # Modify __contains__ to work correctly when __missing__ is present
     def __contains__(self, key):
-        return key in self.data
+        return key in self._dict
 
     # Now, add the methods in dicts but not in MutableMapping
-    def __repr__(self): return repr(self.data)
+    def __repr__(self): return repr(self._dict)
     def copy(self):
         if self.__class__ is _OrderedDictDelegator:
-            return _OrderedDictDelegator(self.data.copy())
+            return _OrderedDictDelegator(self._dict.copy())
         import copy
-        data = self.data
+        data = self._dict
         try:
-            self.data = OrderedDict
+            self._dict = self._dict_type()
             c = copy.copy(self)
         finally:
-            self.data = data
+            self._dict = data
         c.update(self)
         return c
     @classmethod
@@ -409,9 +409,14 @@ def fromkeys(cls, iterable, value=None):
             d[key] = value
         return d
 
+class _OrderedDictDelegator(Ordered, _BaseDictDelegator):
+    _dict_type = OrderedDict
+
+class _DictDelegator(DefinitelyUnordered, _BaseDictDelegator):
+    _dict_type = dict
 
                 
-class Bag(_MutableBagMixin, collections.UserDict):
+class Bag(_MutableBagMixin, _DictDelegator):
     '''
     A bag that counts items.
     
@@ -430,7 +435,6 @@ class Bag(_MutableBagMixin, collections.UserDict):
     that follow. Only positive integers are allowed as counts.
     
     '''                
-    _dict = property(lambda self: self.data)
     
                 
 class OrderedBag(_OrderedBagMixin, _MutableBagMixin, _OrderedDictDelegator):
@@ -455,8 +459,6 @@ class OrderedBag(_OrderedBagMixin, _MutableBagMixin, _OrderedDictDelegator):
     `collections.OrderedDict`.)
     
     '''
-    _dict = property(lambda self: self.data)
-    
     
                 
 class FrozenBag(_BaseBagMixin, FrozenDict):
diff --git a/source_py3/test_python_toolbox/test_nifty_collections/test_bagging.py b/source_py3/test_python_toolbox/test_nifty_collections/test_bagging.py
@@ -69,6 +69,15 @@ def test_common(self):
         assert self.bag_type({'a': 0, 'b': 1,}) == \
                                              self.bag_type({'c': 0, 'b': 1,})
         
+    def test_no_visible_dict(self):
+        bag = self.bag_type('abc')
+        with cute_testing.RaiseAssertor(AttributeError):
+            bag.data
+        with cute_testing.RaiseAssertor(AttributeError):
+            bag.dict
+            
+        
+        
     def test_repr(self):
         assert re.match(
             self._repr_result_pattern, 
