Add IdMapping video

Author: jamesmurphy-mc

README.md

@@ -12,6 +12,7 @@ James and his team are available for consulting, contracting, code reviews, and
 
 | N   | Code | Video | 
 |-----| --- |--- |
+| 128 | [src](videos/128_id_mapping) | [A forbidden Python technique to put ANYTHING in a dict or set.](https://youtu.be/NpdNDTncxwA) |
 | 127 | [src](videos/127_accidentally_quadratic_unique_sum) | [Don't make this big O mistake!](https://youtu.be/PXWL_Xzyrp4) |
 | 126 | [src](videos/126_attrs_revolution) | [Why I prefer attrs over dataclasses](https://youtu.be/1S2h11XronA) |
 | 125 | [src](videos/125_type_or_class) | [type(obj) vs. obj.__class__ in Python, and changing an object's class.](https://youtu.be/5vpdzRbfTIM) |

videos/128_id_mapping/demo.py

@@ -0,0 +1,95 @@
+# my_dict = {}
+#
+# not_hashable = [1, 2, 3]
+# my_dict[not_hashable] = ...  # ERROR
+#
+# val = my_dict[not_hashable]
+
+
+def set_in(set_mem, x):
+    idx = hash(x) % len(set_mem)
+    link = set_mem[idx]
+    while link is not None:
+        if link.value == x:
+            return True
+        link = link.next
+    return False
+
+
+class UnsafeList(list):
+    def __hash__(self):
+        return hash(tuple(self))
+
+
+x = UnsafeList([1, 2, 3])
+my_dict = {x: "subscribe"}
+x[0] = 0
+
+
+# print(my_dict[x])  # KeyError!
+
+
+class Hashable:
+    pass
+    # __hash__ defined automatically
+    # __eq__ defined automatically
+
+
+class NotHashable:
+    def __eq__(self, other):
+        return self is other
+
+    # __hash__ set to None automatically
+
+
+class SadSet:
+    def __init__(self):
+        self.data = []
+
+    def add(self, value):
+        if value not in self.data:
+            self.data.append(value)
+
+    def remove(self, value):
+        if value in self.data:
+            self.data.remove(value)
+
+    def __contains__(self, value):
+        return value in self.data
+
+    def __len__(self):
+        return len(self.data)
+
+    def __iter__(self):
+        return iter(self.data)
+
+
+class A:
+    pass
+
+
+x = A()
+print(id(x))  # 2086544423440
+
+del x
+y = A()
+print(id(y))  # 2086544423440 (SAME!)
+
+from id_mapping import IdMapping, IdSet
+
+d = IdMapping()
+
+my_list = [1, 2, 3]
+d[my_list] = "subscribe"
+my_list[0] = 0
+
+s = d[my_list]
+assert s == "subscribe"  # SUCCESS!
+
+collection = IdSet()
+
+n = 257
+collection.add(n)
+collection.add(n)
+
+print(collection)  # {257}

videos/128_id_mapping/id_mapping.py

@@ -0,0 +1,144 @@
+from collections.abc import MutableMapping, MutableSet
+from typing import TypeVar
+
+KeyT = TypeVar('KeyT')
+ValT = TypeVar('ValT')
+
+
+class IdMapping(MutableMapping[KeyT, ValT]):
+    """A mapping that internally stores keys by their identity id(key).
+
+    Keys can be ANYTHING, even non-hashable objects.
+    Stores strong references to all keys and values.
+    When determining if IdMappings are equal, keys are compared by identity, but values are compared by ==.
+    Warning: key1 == key2 does NOT imply id(key1) == id(key2), which may be confusing if your keys are e.g. ints.
+
+    >>> not_hashable = [1, 2, 3]
+    >>> mapping = IdMapping()
+    >>> mapping[not_hashable] = "hello"
+    >>> not_hashable in mapping
+    True
+    >>> mapping[not_hashable]
+    'hello'
+    >>> not_hashable[0] = 0 # can even mutate the keys, it doesn't matter!
+    >>> mapping[not_hashable]
+    'hello'
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._data: dict[int, tuple[KeyT, ValT]] = {}
+        """id(key) -> (key, value)"""
+
+        self.update(*args, **kwargs)
+
+    def __getitem__(self, item):
+        try:
+            key, val = self._data[id(item)]
+        except KeyError as exc:
+            raise KeyError(item) from exc
+        return val
+
+    def __setitem__(self, key, value):
+        self._data[id(key)] = (key, value)
+
+    def __delitem__(self, key):
+        try:
+            del self._data[id(key)]
+        except KeyError as exc:
+            raise KeyError(key) from exc
+
+    def __iter__(self):
+        for key, val in self._data.values():
+            yield key
+
+    def __len__(self):
+        return len(self._data)
+
+    def __eq__(self, other):
+        if not isinstance(other, IdMapping):
+            return super().__eq__(other)
+        if len(self) != len(other):
+            return False
+        for key, val in self._data.values():
+            try:
+                if other[key] != val:
+                    return False
+            except KeyError:
+                return False
+        return True
+
+    def equal_keys(self, other):
+        if not isinstance(other, IdMapping):
+            return self.keys() == other.keys()
+        return self._data.keys() == other._data.keys()
+
+    def clear(self) -> None:
+        self._data.clear()
+
+
+class IdSet(MutableSet[ValT]):
+    """A set that internally stores values by their identity id(value).
+
+    Values can be ANYTHING, even non-hashable objects.
+    Stores strong references to all values.
+    When determining if IdSets are equal, values are compared by identity, not by using ==.
+    Warning: val1 == val2 does NOT imply id(val1) == id(val2), which may be confusing if your values are e.g. ints.
+
+    >>> not_hashable = [1, 2, 3]
+    >>> seen = IdSet()
+    >>> seen.add(not_hashable)
+    >>> not_hashable in seen
+    True
+    >>> not_hashable[0] = 0 # can even mutate the values, it doesn't matter!
+    >>> not_hashable in seen
+    True
+    """
+
+    def __init__(self, *others):
+        self._data: dict[int, ValT] = {}
+        """id(key) -> value"""
+
+        self.update(*others)
+
+    def __contains__(self, item):
+        return id(item) in self._data
+
+    def add(self, value: ValT) -> None:
+        self._data[id(value)] = value
+
+    def discard(self, value: ValT) -> None:
+        self._data.pop(id(value), None)
+
+    def __iter__(self):
+        yield from self._data.values()
+
+    def __len__(self):
+        return len(self._data)
+
+    def __le__(self, other):
+        if not isinstance(other, IdSet):
+            return super().__le__(other)
+        return self._data.keys() <= other._data.keys()
+
+    def __ge__(self, other):
+        if not isinstance(other, IdSet):
+            return super().__ge__(other)
+        return self._data.keys() >= other._data.keys()
+
+    def clear(self) -> None:
+        self._data.clear()
+
+    def update(self, *others):
+        for other in others:
+            self.__ior__(other)
+
+    def intersection_update(self, *others):
+        for other in others:
+            self.__iand__(other)
+
+    def difference_update(self, *others):
+        for other in others:
+            self.__isub__(other)
+
+    def symmetric_difference_update(self, other):
+        self.__ixor__(other)

videos/128_id_mapping/test_id_mapping.py

@@ -0,0 +1,116 @@
+import pytest
+
+from id_mapping import IdMapping, IdSet
+
+
+def test_id_mapping_set_get_list():
+    counts = [1, 2, 3]
+
+    mapping = IdMapping()
+    assert not mapping
+    assert len(mapping) == 0
+
+    mapping[counts] = 1234
+
+    assert mapping
+    assert len(mapping) == 1
+    assert mapping[counts] == 1234
+    assert counts in mapping
+    assert counts in mapping.keys()
+    assert list(mapping.keys())[0] is counts
+
+    del mapping[counts]
+    assert not mapping
+    assert len(mapping) == 0
+
+
+def test_id_set_set_get_list():
+    counts = [1, 2, 3]
+
+    id_set = IdSet()
+
+    assert not id_set
+    assert len(id_set) == 0
+
+    id_set.add(counts)
+
+    assert len(id_set) == 1
+    assert counts in id_set
+    assert list(id_set)[0] is counts
+
+    id_set.add(counts)
+
+    assert len(id_set) == 1
+    assert counts in id_set
+    assert list(id_set)[0] is counts
+
+    id_set.remove(counts)
+
+    assert counts not in id_set
+    assert len(id_set) == 0
+    assert not id_set
+
+
+def test_compare_to_normal_set():
+    s = set()
+    s.add(frozenset({1, 2, 3}))
+    assert len(s) == 1
+    s.add(frozenset({1, 2, 3}))
+    assert len(s) == 1
+
+    s = IdSet()
+    s.add(frozenset({1, 2, 3}))
+    assert len(s) == 1
+    s.add(frozenset({1, 2, 3}))
+    assert len(s) == 2
+
+    s = IdSet()
+    item = frozenset({1, 2, 3})
+    s.add(item)
+    assert len(s) == 1
+    s.add(item)
+    assert len(s) == 1
+
+
+def do_once(stuff, op):
+    seen = set()
+    for x in stuff:
+        if x in seen:
+            continue
+        op(x)
+
+
+def test_ints_trouble():
+    mapping = IdMapping()
+
+    mapping[257] = "find me"
+    with pytest.raises(KeyError):
+        mapping[int(float(257))]  # even though the keys are equal, they have different ids!
+
+
+def test_python_doesnt_let_you_store_things():
+    x = set()
+
+    with pytest.raises(TypeError):
+        x.add([])
+
+    class A:
+        pass
+
+    x.add(A())  # OK
+
+    class B:
+        def __eq__(self, other):
+            return self is other
+
+    with pytest.raises(TypeError):
+        x.add(B())
+
+    class C:
+        def __eq__(self, other):
+            return self is other
+
+        def __hash__(self):
+            return 42  # bad hash!
+
+    x.add(C())  # OK, even though hash is bad