Minor improvements to collections items. (#14)

* Changed Item.__repr__.
* Updated collections.
* Added list to ItemDict.
* Added tests for MultiEntryDict.
* Updated collection docs.

Author: synchronizing

README.md

@@ -231,7 +231,7 @@ print(nt.forced)    #  {'hello': 'world'}
 </details>
 
 <details>
-  <summary><a href="https://synchronizing.github.io/toolbox/module/collections.html#toolbox.collections.item.Item"><code>BidirectionalDict</code></a> — Dictionary with two-way capabilities.</summary><br>
+  <summary><a href="https://synchronizing.github.io/toolbox/module/collections.html#toolbox.collections.mapping.BidirectionalDict"><code>BidirectionalDict</code></a> — Dictionary with two-way capabilities.</summary><br>
 
 ```python
 from toolbox import BidirectionalDict
@@ -273,33 +273,33 @@ print(d1) #  {'hello': 'world'}
   <summary><a href="https://synchronizing.github.io/toolbox/module/collections.html#toolbox.collections.mapping.UnderscoreAccessDict"><code>UnderscoreAccessDict</code></a> — Dictionary with underscore access.</summary><br>
 
 ```python
-from toolbox import OverloadedDict
-
-d1 = OverloadedDict({"hello": "world"})
-d2 = OverloadedDict({"ola": "mundo"})
+from toolbox import UnderscoreAccessDict
 
-d1 += d2
-print(d1) #  {'hello': 'world', 'ola': 'mundo'}
-
-d1 -= d2
-print(d1) #  {'hello': 'world'}
+d = UnderscoreAccessDict({"hello": "world"})
+print(d.hello) #  'world'
 ```
 </details>
 
 <details>
   <summary><a href="https://synchronizing.github.io/toolbox/module/collections.html#toolbox.collections.mapping.FrozenDict"><code>FrozenDict</code></a> — Dictionary that is frozen.</summary><br>
 
 ```python
-from toolbox import OverloadedDict
+from toolbox import FrozenDict
 
-d1 = OverloadedDict({"hello": "world"})
-d2 = OverloadedDict({"ola": "mundo"})
+d = FrozenDict({"hello": "world"})
+d["hello"] = "mundo" # KeyError: Cannot set key and value because this is a frozen dictionary.
+```
+</details>
 
-d1 += d2
-print(d1) #  {'hello': 'world', 'ola': 'mundo'}
+<details>
+  <summary><a href="https://synchronizing.github.io/toolbox/module/collections.html#toolbox.collections.mapping.MultiEntryDict"><code>MultiEntryDict</code></a> — Dictionary that can have multiple entries for the same key.</summary><br>
 
-d1 -= d2
-print(d1) #  {'hello': 'world'}
+```python
+from toolbox import MultiEntryDict
+
+d = MultiEntryDict({"hello": "world"})
+d["hello"] = "mundo"
+print(d) #  {'hello': ['world', 'mundo']}
 ```
 </details>
 

docs/source/module/collections.rst

@@ -155,6 +155,7 @@ Note that :py:class:`*Dict` types below can be combined together (as mixins) to
 .. autoclass:: toolbox.collections.mapping.OverloadedDict(BaseDict)
 .. autoclass:: toolbox.collections.mapping.UnderscoreAccessDict(BaseDict)
 .. autoclass:: toolbox.collections.mapping.FrozenDict(BaseDict)
+.. autoclass:: toolbox.collections.mapping.MultiEntryDict(BaseDict)
 .. autoclass:: toolbox.collections.mapping.ItemDict(BaseDict)
 
 ----

tests/test_collections.py

@@ -8,6 +8,7 @@
     UnderscoreAccessDict,
     FrozenDict,
     ItemDict,
+    MultiEntryDict,
     fdict,
     nestednamedtuple,
 )
@@ -109,22 +110,10 @@ def test_item_str(self):
         assert str(item) == item.string
 
     def test_item_repr(self):
-        assert (
-            repr(Item(100))
-            == "Item(bytes=b'100', str='100', int=100, bool=True, original_type=int)"
-        )
-        assert (
-            repr(Item(None))
-            == "Item(bytes=b'', str='', int=None, bool=False, original_type=NoneType)"
-        )
-        assert (
-            repr(Item(True))
-            == "Item(bytes=b'1', str='1', int=1, bool=True, original_type=bool)"
-        )
-        assert (
-            repr(Item("hello"))
-            == "Item(bytes=b'hello', str='hello', int=None, bool=True, original_type=str)"
-        )
+        assert repr(Item(100)) == "100"
+        assert repr(Item(None)) == "None"
+        assert repr(Item(True)) == "True"
+        assert repr(Item("hello")) == "hello"
 
     def test_item_byte_item_err(self):
         with pytest.raises(TypeError):
@@ -167,6 +156,11 @@ def test_object_dict_data(self):
             d = ObjectDict({"hello": "world"})
             assert d.hello == "world"
 
+        def test_object_dict_setattr(self):
+            d = ObjectDict({"hello": "world"})
+            d.ola = "mundo"
+            assert d.ola == "mundo"
+
     class Test_collection_overloaded:
         def test_overloaded_dict_type(self):
             assert isinstance(OverloadedDict(), dict)
@@ -210,6 +204,20 @@ def test_underscore_access_str(self):
             assert d["key"] == "value"
             assert d["_100"] == "one hundred"
 
+        def test_underscore_access_bytes(self):
+            d = UnderscoreAccessDict(
+                {
+                    b"hello world": "ola mundo",
+                    b"ola_mundo": "hello world",
+                    b"key": "value",
+                    b"100": "one hundred",
+                }
+            )
+            assert d[b"hello_world"] == "ola mundo"
+            assert d[b"ola_mundo"] == "hello world"
+            assert d[b"key"] == "value"
+            assert d[b"_100"] == "one hundred"
+
     class Test_collection_frozen:
         def test_frozen_init(self):
             d = FrozenDict({"hello": "world"})
@@ -223,6 +231,14 @@ def test_frozen_update(self):
             with pytest.raises(KeyError):
                 d.update({"ola": "mundo"})
 
+    class Test_collection_multi:
+        def test_multi_init(self):
+            d = MultiEntryDict({"hello": "world", "hello": "mundo"})
+            assert d["hello"] == "mundo"
+
+            d["hello"] = "globo"
+            assert d["hello"] == ["mundo", "globo"]
+
     class Test_collection_item:
         def test_item_init(self):
             d = ItemDict({"100": "one hundred"})
@@ -233,6 +249,9 @@ def test_item_setitem(self):
             d[100] = "one hundred"
             assert d["100"] == d[b"100"] == d[100] == d[Item(100)]
 
+            d[200] = [1, 2, 3]
+            assert d["200"] == d[b"200"] == d[200] == d[Item(200)]
+
         def test_item_delitem(self):
             d = ItemDict()
             d[100] = "one hundred"

toolbox/collections/item.py

@@ -168,13 +168,7 @@ def __str__(self) -> str:
         return self.string
 
     def __repr__(self) -> str:
-        return "Item(bytes={}, str='{}', int={}, bool={}, original_type={})".format(
-            self.raw,
-            self.string,
-            self.integer,
-            self.boolean,
-            self._type.__name__,
-        )
+        return str(self.original)
 
     @staticmethod
     def byte_item(item: ItemType) -> "Item":

toolbox/collections/mapping.py

@@ -70,7 +70,7 @@ def update(self, dictionary: dict = Optional[dict], **kwargs):
 
 
 class ObjectDict(BaseDict):
-    """Dictionary that can be accessed as though it was an object.
+    """Dictionary that can be accessed and set as though it was an object.
 
     Example:
 
@@ -82,11 +82,17 @@ class ObjectDict(BaseDict):
             print(d) # >>> <ObjectDict {'hello': 'world'}>
 
             print(d.hello) # >>> 'world'
+
+            d.hello = "mundo"
+            print(d.hello) # >>> 'mundo'
     """
 
     def __getattr__(self, key: Any) -> Any:
         return self.__getitem__(key)
 
+    def __setattr__(self, key: str, value: Any):
+        return self.__setitem__(key, value)
+
 
 class OverloadedDict(BaseDict):
     """Dictionary that can be added or subtracted.
@@ -140,8 +146,13 @@ class UnderscoreAccessDict(BaseDict):
     """
 
     def __getitem__(self, key: Any) -> Any:
-        utw = key.replace("_", " ")
-        wtu = key.replace("_", "")
+        if isinstance(key, bytes):
+            utw = key.replace(b"_", b" ")
+            wtu = key.replace(b"_", b"")
+        else:
+            utw = key.replace("_", " ")
+            wtu = key.replace("_", "")
+
         if utw in self:
             return super(UnderscoreAccessDict, self).__getitem__(utw)
         elif wtu in self:
@@ -192,7 +203,7 @@ def __setitem__(self, key, value):
             if isinstance(self[key], list):
                 self[key].append(value)
             else:
-                self[key] = [self[key], value]
+                super().__setitem__(key, [self[key], value])
         else:
             super(MultiEntryDict, self).__setitem__(key, value)
 
@@ -208,25 +219,33 @@ class ItemDict(BaseDict):
 
             d = ItemDict({"100": "one hundred"})
             print(d)
-            # >>> <ItemDict {Item(bytes=b'100', str='100', int=100, bool=True, original_type=str): Item(bytes=b'one hundred', str='one hundred', int=None, bool=True, original_type=str)}>
+            # >>> <ItemDict {100: one hundred}>
 
             print(d["100"] == d[100] == d[b"100"]) # >>> True
     """
 
     def __init__(self, dictionary: Optional[dict] = None, **kwargs):
         dictionary = dictionary or {}
-        super(ItemDict, self).__init__(
-            {
-                **{Item(k): Item(v) for k, v in dictionary.items()},
-                **{Item(k): Item(v) for k, v in kwargs.items()},
-            }
-        )
+        kwargs = kwargs or {}
+        dictionary = {**dictionary, **kwargs}
+
+        new = {}
+        for k, v in dictionary.items():
+            if isinstance(v, list):
+                new[Item(k)] = [Item(i) for i in v]
+            else:
+                new[Item(k)] = Item(v)
+
+        return super(ItemDict, self).__init__(new)
 
     def __getitem__(self, key: ItemType):
         return super(ItemDict, self).__getitem__(Item(key))
 
     def __setitem__(self, key: ItemType, value: ItemType):
-        super(ItemDict, self).__setitem__(Item(key), Item(value))
+        if isinstance(value, list):
+            super(ItemDict, self).__setitem__(Item(key), [Item(i) for i in value])
+        else:
+            super(ItemDict, self).__setitem__(Item(key), Item(value))
 
     def __delitem__(self, key: ItemType):
         super(ItemDict, self).__delitem__(Item(key))