readability

src/hooked_containers/common.py

@@ -44,3 +44,12 @@ class HookedContainer(ABC, Sized, Iterable[T], Container[T]):
 
     @abstractmethod
     def insert(self, index, value): ...
+
+    # Custom Methods
+
+    def get_nested(self, keys):
+        """Recursively call __getitem__ with each key in the iterable."""
+        result = self
+        for key in keys:
+            result = result[key]
+        return result

src/hooked_containers/mapping.py

@@ -2,6 +2,7 @@ from collections.abc import MutableMapping, MutableSequence, Sequence
 from copy import copy
 from typing import TypeVar
 
+from . import events as e
 from .common import HookedContainer, MutableNesting
 from .sequence import HookedList
 
@@ -23,29 +24,23 @@ class HookedMapping(HookedContainer[T], MutableMapping[T, MutableNesting[T]]):
 
     def __getitem__(self, key: T) -> MutableNesting[T]:
         value = self._data[key]
+        new_path = copy(self._path)
+        new_path.append(key)
         match value:
             case MutableMapping() as mapping:
-                new_path = copy(self._path)
+                return HookedMapping(hook=self.hook, existing=mapping, path=new_path)
-                new_path.append(key)
-                return type(self)(self.hook, existing=mapping, path=new_path)
             case MutableSequence() as seq:
-                new_path = copy(self._path)
+                return HookedList(hook=self.hook, existing=seq, path=new_path)
-                new_path.append(key)
-                return HookedList(self.hook, existing=seq, path=new_path)
             case _ as item:
                 return item
 
     def __setitem__(self, key: T, value: MutableNesting[T]) -> None:
         self._data[key] = value
         if self.hook:
-            from . import events as e
-
             self.hook(e.SetItemEvent(index=key, item=value))
 
     def __delitem__(self, key: T) -> None:
         item = self._data[key]
         del self._data[key]
         if self.hook:
-            from . import events as e
+            self.hook(e.RemoveItemEvent(index=key, item=item, path=self._path))
-
-            self.hook(e.RemoveItemEvent(index=key, item=item))

src/hooked_containers/sequence.py

@@ -12,27 +12,30 @@ class HookedList(HookedContainer[T], MutableSequence[T]):
     _data: MutableSequence[T]
     path: MutableSequence[int]
 
-    def __init__(self, hook: HookFunction, existing: MutableSequence[T], path: MutableSequence[int] | None = None):
+    def __init__(
+        self,
+        existing: MutableSequence[T],
+        hook: HookFunction | None = None,
+        path: MutableSequence[int] | None = None,
+    ) -> None:
         self.hook = hook
         match existing:
-            case HookedContainer(_data=seq):
-                self._data = seq
             case MutableSequence() as seq:
                 self._data = seq
+            case HookedContainer(_data=seq):
+                self._data = seq
             case _ as it:
                 self._data = list(it)
         self._path = list(path) if path is not None else []
 
     def __getitem__(self, s):
+        new_path = copy(self._path)
+        new_path.append(s)
         match self._data[s]:
             case MutableSequence() as seq:
-                new_path = copy(self._path)
+                return type(self)(seq, self.hook, path=new_path)
-                new_path.append(s)
-                return type(self)(self.hook, existing=seq, path=new_path)
             case HookedContainer(_data=seq):
-                new_path = copy(self._path)
+                return type(self)(seq, self.hook, path=new_path)
-                new_path.append(s)
-                return type(self)(self.hook, existing=seq, path=new_path)
             case _ as item:
                 return item
 

tests/test_sequence.py

@@ -12,59 +12,64 @@ def get_id(a: Any):
 class TestHookedList:
     class TestConstruction:
         def test_empty(self):
-            lst = HookedList(None, existing=[])
+            lst = HookedList([])
             assert list(lst) == []
 
         def test_with_items(self):
-            lst = HookedList(None, existing=[1, 2, 3])
+            lst = HookedList([1, 2, 3])
             assert list(lst) == [1, 2, 3]
 
         def test_recreation(self):
             initial = [1, 2, 3]
             initial_id = id(initial)
 
-            lst = HookedList(None, existing=initial)
+            lst = HookedList(initial)
             assert id(lst._data) == initial_id
 
-            lst2 = HookedList(None, existing=lst)
+            lst2 = HookedList(lst)
             assert id(lst2._data) == initial_id
 
     class TestSeqOps:
         def test_len(self):
-            lst = HookedList(None, existing=[1, 2, 3])
+            lst = HookedList([1, 2, 3])
             assert len(lst) == 3
 
         def test_getitem(self):
-            lst = HookedList(None, existing=[1, 2, 3])
+            lst = HookedList([1, 2, 3])
             assert lst[0] == 1
             assert lst[1] == 2
             assert lst[-1] == 3
 
         def test_contains(self):
-            lst = HookedList(None, existing=[1, 2, 3])
+            lst = HookedList([1, 2, 3])
             assert 2 in lst
             assert 4 not in lst
 
         def test_iter(self):
-            lst = HookedList(None, existing=[1, 2, 3])
+            lst = HookedList([1, 2, 3])
             for i, item in enumerate(lst, start=1):
                 assert item == i
 
     class TestMutableOps:
         def test_setitem(self):
             added = []
-            lst = HookedList(lambda e: added.append(e.item), existing=[1, 2, 3])
+            lst = HookedList(
+                [1, 2, [4, 5, [6, 7]]],
+                lambda e: added.append(e.item),
+            )
             lst[0] = 10
             lst.append(20)
-            assert list(lst) == [10, 2, 3, 20]
             assert added == [10, 20]
 
+            lst[2][-1].append(8)
+            assert added == [10, 20, 8]
+
         def test_delitem(self):
-            lst = HookedList(None, existing=[1, 2, 3])
+            lst = HookedList([1, 2, 3])
             del lst[1]
             assert list(lst) == [1, 3]
 
         def test_insert(self):
-            lst = HookedList(None, existing=[1, 3])
+            lst = HookedList([1, 3])
             lst.insert(1, 2)
             assert list(lst) == [1, 2, 3]