datahold 4.0.0.dev40__tar.gz → 4.0.0.dev42__tar.gz

{datahold-4.0.0.dev40 → datahold-4.0.0.dev42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev40
+Version: 4.0.0.dev42
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-4.0.0.dev40 → datahold-4.0.0.dev42}/pyproject.toml

@@ -34,7 +34,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.12"
-version = "4.0.0.dev40"
+version = "4.0.0.dev42"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

{datahold-4.0.0.dev40 → datahold-4.0.0.dev42}/src/datahold/__init__.py

@@ -30,10 +30,28 @@ class SupportsDunderLT[Other](Protocol):
 type Slice[Index] = slice[Index | None, Index | None, Index | None]
 type Sort = SupportsDunderGT[Self] | SupportsDunderGT[Self]  # type: ignore[misc]
 
+
+### HELPER ###
+
+
+def reverse_sequence[Item](
+    sequence: MutableListSlot[Item],
+    length: int,
+) -> abc.Generator[Item, None, None]:
+    frozen: tuple[Item, ...]
+    while True:
+        frozen = sequence.__frozen__()
+        length -= 1
+        if 0 <= length < len(frozen):
+            yield frozen[length]
+        else:
+            break
+
+
 ### LIST-SLOT ###
 
 
-class MutableListSlot[Item]:
+class MutableListSlot[Item](abc.Sequence[Item]):
     """Provide easily customized, slotted, mutable list-like."""
 
     __slots__ = ("_slot",)
@@ -140,15 +158,16 @@ class MutableListSlot[Item]:
     def __iter__(
         self: MutableListSlot[Item], /
     ) -> abc.Generator[Item, None, None]:
+        frozen: tuple[Item, ...]
         i: int
         i = 0
         while True:
-            try:
-                v = self[i]
-            except IndexError:
-                return
-            yield v
-            i += 1
+            frozen = self.__frozen__()
+            if i < len(frozen):
+                yield frozen[i]
+                i += 1
+            else:
+                break
 
     def __le__(
         self: MutableListSlot[Item],
@@ -186,12 +205,11 @@ class MutableListSlot[Item]:
     def __repr__(self: MutableListSlot[Item], /) -> str:
         return f"{type(self).__name__}({list(self.__frozen__())})"
 
-    def __reversed__(
-        self: MutableListSlot[Item], /
-    ) -> abc.Generator[Item, None, None]:
-        i: int
-        for i in reversed(range(len(self))):
-            yield self[i]
+    def __reversed__(self: MutableListSlot[Item], /) -> abc.Iterator[Item]:
+        return reverse_sequence(
+            sequence=self,
+            length=len(self.__frozen__()),
+        )
 
     @overload
     def __setitem__(
@@ -301,4 +319,4 @@ class MutableListSlot[Item]:
 
 setdoc.Basics(
     excepts=(AttributeError, TypeError),
-)(*MutableListSlot.__dict__)
+)(*MutableListSlot.__dict__.values())

{datahold-4.0.0.dev40 → datahold-4.0.0.dev42}/src/datahold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev40
+Version: 4.0.0.dev42
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-4.0.0.dev40 → datahold-4.0.0.dev42}/tests/test_MutableListSlot.py

@@ -16,20 +16,22 @@ __all__: list[str] = [
     "TestMethodReverse",
     "TestMethodSort",
     "TestOperatorAdd",
+    "TestOperatorContains",
+    "TestOperatorDelItem",
+    "TestOperatorEqual",
+    "TestOperatorGetItem",
+    "TestOperatorGreaterThan",
+    "TestOperatorGreaterThanOrEqual",
     "TestOperatorIAdd",
-    "TestOperatorMul",
-    "TestOperatorRMul",
     "TestOperatorIMul",
-    "TestOperatorEqual",
-    "TestOperatorNotEqual",
+    "TestOperatorIterSequence",
     "TestOperatorLessThan",
     "TestOperatorLessThanOrEqual",
-    "TestOperatorGreaterThan",
-    "TestOperatorGreaterThanOrEqual",
-    "TestOperatorContains",
-    "TestOperatorGetItem",
+    "TestOperatorMul",
+    "TestOperatorNotEqual",
+    "TestOperatorRMul",
+    "TestOperatorReversedSequence",
     "TestOperatorSetItem",
-    "TestOperatorDelItem",
 ]
 
 
@@ -293,6 +295,103 @@ class TestOperatorAdd(unittest.TestCase):
         self.assertEqual(list(value), [1, 2])
 
 
+class TestOperatorContains(unittest.TestCase):
+    def test_contains_first_element(self: Self, /) -> None:
+        self.assertTrue(1 in MutableListSlot([1, 2, 3]))
+
+    def test_contains_last_element(self: Self, /) -> None:
+        self.assertTrue(3 in MutableListSlot([1, 2, 3]))
+
+    def test_does_not_contain_missing_element(self: Self, /) -> None:
+        self.assertFalse(4 in MutableListSlot([1, 2, 3]))
+
+    def test_empty_slot_contains_nothing(self: Self, /) -> None:
+        self.assertFalse(1 in MutableListSlot([]))
+
+
+class TestOperatorDelItem(unittest.TestCase):
+    def test_delete_first_item(self: Self, /) -> None:
+        value = MutableListSlot([1, 2, 3])
+        del value[0]
+        self.assertEqual(list(value), [2, 3])
+
+    def test_delete_last_item(self: Self, /) -> None:
+        value = MutableListSlot([1, 2, 3])
+        del value[-1]
+        self.assertEqual(list(value), [1, 2])
+
+    def test_delete_slice(self: Self, /) -> None:
+        value = MutableListSlot([1, 2, 3, 4])
+        del value[1:3]
+        self.assertEqual(list(value), [1, 4])
+
+    def test_delete_out_of_range_raises(self: Self, /) -> None:
+        value = MutableListSlot([1, 2])
+        with self.assertRaises(IndexError):
+            del value[5]
+
+
+class TestOperatorEqual(unittest.TestCase):
+    def test_equal_same_contents(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2]) == MutableListSlot([1, 2]))
+
+    def test_equal_empty_lists(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([]) == MutableListSlot([]))
+
+    def test_not_equal_different_values(self: Self, /) -> None:
+        self.assertFalse(MutableListSlot([1, 2]) == MutableListSlot([1, 3]))
+
+    def test_not_equal_different_lengths(self: Self, /) -> None:
+        self.assertFalse(MutableListSlot([1, 2]) == MutableListSlot([1, 2, 3]))
+
+
+class TestOperatorGetItem(unittest.TestCase):
+    def test_get_first_item(self: Self, /) -> None:
+        value = MutableListSlot([10, 20, 30])
+        self.assertEqual(value[0], 10)
+
+    def test_get_last_item_with_negative_index(self: Self, /) -> None:
+        value = MutableListSlot([10, 20, 30])
+        self.assertEqual(value[-1], 30)
+
+    def test_get_slice(self: Self, /) -> None:
+        value = MutableListSlot([1, 2, 3, 4])
+        self.assertEqual(value[1:3], MutableListSlot([2, 3]))
+
+    def test_out_of_range_index_raises(self: Self, /) -> None:
+        value = MutableListSlot([1, 2])
+        with self.assertRaises(IndexError):
+            value[5]
+
+
+class TestOperatorGreaterThan(unittest.TestCase):
+    def test_greater_than_by_first_element(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([2, 0]) > MutableListSlot([1, 9]))
+
+    def test_greater_than_by_later_element(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 3]) > MutableListSlot([1, 2]))
+
+    def test_longer_list_is_greater_than_prefix(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2, 3]) > MutableListSlot([1, 2]))
+
+    def test_equal_list_is_not_greater_than(self: Self, /) -> None:
+        self.assertFalse(MutableListSlot([1, 2]) > MutableListSlot([1, 2]))
+
+
+class TestOperatorGreaterThanOrEqual(unittest.TestCase):
+    def test_greater_value_is_greater_or_equal(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([2]) >= MutableListSlot([1]))
+
+    def test_equal_value_is_greater_or_equal(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2]) >= MutableListSlot([1, 2]))
+
+    def test_longer_list_is_greater_or_equal_to_prefix(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2]) >= MutableListSlot([1]))
+
+    def test_smaller_value_is_not_greater_or_equal(self: Self, /) -> None:
+        self.assertFalse(MutableListSlot([1]) >= MutableListSlot([2]))
+
+
 class TestOperatorIAdd(unittest.TestCase):
     def test_iadd_nonempty_list(self: Self, /) -> None:
         value = MutableListSlot([1, 2])
@@ -316,6 +415,34 @@ class TestOperatorIAdd(unittest.TestCase):
         self.assertEqual(list(value), [1, 2, 3])
 
 
+class TestOperatorLessThan(unittest.TestCase):
+    def test_less_than_by_first_element(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 9]) < MutableListSlot([2, 0]))
+
+    def test_less_than_by_later_element(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2]) < MutableListSlot([1, 3]))
+
+    def test_prefix_is_less_than_longer_list(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2]) < MutableListSlot([1, 2, 3]))
+
+    def test_equal_list_is_not_less_than(self: Self, /) -> None:
+        self.assertFalse(MutableListSlot([1, 2]) < MutableListSlot([1, 2]))
+
+
+class TestOperatorLessThanOrEqual(unittest.TestCase):
+    def test_less_value_is_less_or_equal(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1]) <= MutableListSlot([2]))
+
+    def test_equal_value_is_less_or_equal(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1, 2]) <= MutableListSlot([1, 2]))
+
+    def test_prefix_is_less_or_equal(self: Self, /) -> None:
+        self.assertTrue(MutableListSlot([1]) <= MutableListSlot([1, 2]))
+
+    def test_greater_value_is_not_less_or_equal(self: Self, /) -> None:
+        self.assertFalse(MutableListSlot([2]) <= MutableListSlot([1]))
+
+
 class TestOperatorMul(unittest.TestCase):
     def test_multiply_by_positive_integer(self: Self, /) -> None:
         result = MutableListSlot([1, 2]) * 3
@@ -334,24 +461,6 @@ class TestOperatorMul(unittest.TestCase):
         self.assertEqual(list(result), [])
 
 
-class TestOperatorRMul(unittest.TestCase):
-    def test_rmul_by_positive_integer(self: Self, /) -> None:
-        result = 3 * MutableListSlot([1, 2])
-        self.assertEqual(list(result), [1, 2, 1, 2, 1, 2])
-
-    def test_rmul_by_one(self: Self, /) -> None:
-        result = 1 * MutableListSlot([1, 2])
-        self.assertEqual(list(result), [1, 2])
-
-    def test_rmul_by_zero(self: Self, /) -> None:
-        result = 0 * MutableListSlot([1, 2])
-        self.assertEqual(list(result), [])
-
-    def test_rmul_by_negative_integer(self: Self, /) -> None:
-        result = -3 * MutableListSlot([1, 2])
-        self.assertEqual(list(result), [])
-
-
 class TestOperatorIMul(unittest.TestCase):
     def test_imul_by_positive_integer(self: Self, /) -> None:
         value = MutableListSlot([1, 2])
@@ -374,18 +483,63 @@ class TestOperatorIMul(unittest.TestCase):
         self.assertEqual(list(value), [])
 
 
-class TestOperatorEqual(unittest.TestCase):
-    def test_equal_same_contents(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2]) == MutableListSlot([1, 2]))
+class TestOperatorIterSequence(unittest.TestCase):
+    def test_shrinking_makes_next_index_out_of_range(self: Self, /) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = iter(values)
 
-    def test_equal_empty_lists(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([]) == MutableListSlot([]))
+        self.assertEqual(next(iterator), 0)
+        del values[1:]
 
-    def test_not_equal_different_values(self: Self, /) -> None:
-        self.assertFalse(MutableListSlot([1, 2]) == MutableListSlot([1, 3]))
+        with self.assertRaises(StopIteration):
+            next(iterator)
 
-    def test_not_equal_different_lengths(self: Self, /) -> None:
-        self.assertFalse(MutableListSlot([1, 2]) == MutableListSlot([1, 2, 3]))
+    def test_exhaustion_remains_after_regrowth(self: Self, /) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = iter(values)
+
+        self.assertEqual(next(iterator), 0)
+        del values[1:]
+
+        with self.assertRaises(StopIteration):
+            next(iterator)
+
+        values.extend([10, 11, 12, 13])
+
+        with self.assertRaises(StopIteration):
+            next(iterator)
+
+    def test_regrowth_before_next_restores_valid_index(self: Self, /) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = iter(values)
+
+        self.assertEqual(next(iterator), 0)
+        del values[1:]
+        values.extend([10, 11, 12])
+
+        self.assertEqual(next(iterator), 10)
+
+    def test_deletion_before_cursor_does_not_repair_index(
+        self: Self, /
+    ) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = iter(values)
+
+        self.assertEqual(next(iterator), 0)
+        del values[0]
+
+        self.assertEqual(next(iterator), 2)
+
+    def test_growth_before_exhaustion_is_seen(self: Self, /) -> None:
+        values = MutableListSlot([0, 1])
+        iterator = iter(values)
+
+        self.assertEqual(next(iterator), 0)
+        self.assertEqual(next(iterator), 1)
+
+        values.append(2)
+
+        self.assertEqual(next(iterator), 2)
 
 
 class TestOperatorNotEqual(unittest.TestCase):
@@ -402,93 +556,80 @@ class TestOperatorNotEqual(unittest.TestCase):
         self.assertFalse(MutableListSlot([]) != MutableListSlot([]))
 
 
-class TestOperatorLessThan(unittest.TestCase):
-    def test_less_than_by_first_element(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 9]) < MutableListSlot([2, 0]))
-
-    def test_less_than_by_later_element(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2]) < MutableListSlot([1, 3]))
-
-    def test_prefix_is_less_than_longer_list(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2]) < MutableListSlot([1, 2, 3]))
-
-    def test_equal_list_is_not_less_than(self: Self, /) -> None:
-        self.assertFalse(MutableListSlot([1, 2]) < MutableListSlot([1, 2]))
-
-
-class TestOperatorLessThanOrEqual(unittest.TestCase):
-    def test_less_value_is_less_or_equal(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1]) <= MutableListSlot([2]))
-
-    def test_equal_value_is_less_or_equal(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2]) <= MutableListSlot([1, 2]))
-
-    def test_prefix_is_less_or_equal(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1]) <= MutableListSlot([1, 2]))
+class TestOperatorRMul(unittest.TestCase):
+    def test_rmul_by_positive_integer(self: Self, /) -> None:
+        result = 3 * MutableListSlot([1, 2])
+        self.assertEqual(list(result), [1, 2, 1, 2, 1, 2])
 
-    def test_greater_value_is_not_less_or_equal(self: Self, /) -> None:
-        self.assertFalse(MutableListSlot([2]) <= MutableListSlot([1]))
+    def test_rmul_by_one(self: Self, /) -> None:
+        result = 1 * MutableListSlot([1, 2])
+        self.assertEqual(list(result), [1, 2])
 
+    def test_rmul_by_zero(self: Self, /) -> None:
+        result = 0 * MutableListSlot([1, 2])
+        self.assertEqual(list(result), [])
 
-class TestOperatorGreaterThan(unittest.TestCase):
-    def test_greater_than_by_first_element(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([2, 0]) > MutableListSlot([1, 9]))
+    def test_rmul_by_negative_integer(self: Self, /) -> None:
+        result = -3 * MutableListSlot([1, 2])
+        self.assertEqual(list(result), [])
 
-    def test_greater_than_by_later_element(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 3]) > MutableListSlot([1, 2]))
 
-    def test_longer_list_is_greater_than_prefix(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2, 3]) > MutableListSlot([1, 2]))
+class TestOperatorReversedSequence(unittest.TestCase):
+    def test_shrinking_makes_next_index_out_of_range(self: Self, /) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = reversed(values)
 
-    def test_equal_list_is_not_greater_than(self: Self, /) -> None:
-        self.assertFalse(MutableListSlot([1, 2]) > MutableListSlot([1, 2]))
+        self.assertEqual(next(iterator), 4)
+        del values[1:]
 
+        with self.assertRaises(StopIteration):
+            next(iterator)
 
-class TestOperatorGreaterThanOrEqual(unittest.TestCase):
-    def test_greater_value_is_greater_or_equal(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([2]) >= MutableListSlot([1]))
+    def test_exhaustion_remains_after_regrowth(self: Self, /) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = reversed(values)
 
-    def test_equal_value_is_greater_or_equal(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2]) >= MutableListSlot([1, 2]))
+        self.assertEqual(next(iterator), 4)
+        del values[1:]
 
-    def test_longer_list_is_greater_or_equal_to_prefix(self: Self, /) -> None:
-        self.assertTrue(MutableListSlot([1, 2]) >= MutableListSlot([1]))
+        with self.assertRaises(StopIteration):
+            next(iterator)
 
-    def test_smaller_value_is_not_greater_or_equal(self: Self, /) -> None:
-        self.assertFalse(MutableListSlot([1]) >= MutableListSlot([2]))
+        values.extend([10, 11, 12, 13])
 
+        with self.assertRaises(StopIteration):
+            next(iterator)
 
-class TestOperatorContains(unittest.TestCase):
-    def test_contains_first_element(self: Self, /) -> None:
-        self.assertTrue(1 in MutableListSlot([1, 2, 3]))
+    def test_regrowth_before_next_restores_valid_index(self: Self, /) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = reversed(values)
 
-    def test_contains_last_element(self: Self, /) -> None:
-        self.assertTrue(3 in MutableListSlot([1, 2, 3]))
+        self.assertEqual(next(iterator), 4)
+        del values[1:]
+        values.extend([10, 11, 12, 13])
 
-    def test_does_not_contain_missing_element(self: Self, /) -> None:
-        self.assertFalse(4 in MutableListSlot([1, 2, 3]))
+        self.assertEqual(next(iterator), 12)
 
-    def test_empty_slot_contains_nothing(self: Self, /) -> None:
-        self.assertFalse(1 in MutableListSlot([]))
+    def test_deletion_before_cursor_does_not_repair_index(
+        self: Self, /
+    ) -> None:
+        values = MutableListSlot([0, 1, 2, 3, 4])
+        iterator = reversed(values)
 
+        self.assertEqual(next(iterator), 4)
+        del values[0]
 
-class TestOperatorGetItem(unittest.TestCase):
-    def test_get_first_item(self: Self, /) -> None:
-        value = MutableListSlot([10, 20, 30])
-        self.assertEqual(value[0], 10)
+        self.assertEqual(next(iterator), 4)
 
-    def test_get_last_item_with_negative_index(self: Self, /) -> None:
-        value = MutableListSlot([10, 20, 30])
-        self.assertEqual(value[-1], 30)
+    def test_growth_beyond_initial_reverse_range_is_not_seen(
+        self: Self, /
+    ) -> None:
+        values = MutableListSlot([0, 1, 2])
+        iterator = reversed(values)
 
-    def test_get_slice(self: Self, /) -> None:
-        value = MutableListSlot([1, 2, 3, 4])
-        self.assertEqual(value[1:3], MutableListSlot([2, 3]))
+        values.append(3)
 
-    def test_out_of_range_index_raises(self: Self, /) -> None:
-        value = MutableListSlot([1, 2])
-        with self.assertRaises(IndexError):
-            value[5]
+        self.assertEqual(list(iterator), [2, 1, 0])
 
 
 class TestOperatorSetItem(unittest.TestCase):
@@ -513,27 +654,5 @@ class TestOperatorSetItem(unittest.TestCase):
         self.assertEqual(list(value), [1, 10, 20, 30, 3])
 
 
-class TestOperatorDelItem(unittest.TestCase):
-    def test_delete_first_item(self: Self, /) -> None:
-        value = MutableListSlot([1, 2, 3])
-        del value[0]
-        self.assertEqual(list(value), [2, 3])
-
-    def test_delete_last_item(self: Self, /) -> None:
-        value = MutableListSlot([1, 2, 3])
-        del value[-1]
-        self.assertEqual(list(value), [1, 2])
-
-    def test_delete_slice(self: Self, /) -> None:
-        value = MutableListSlot([1, 2, 3, 4])
-        del value[1:3]
-        self.assertEqual(list(value), [1, 4])
-
-    def test_delete_out_of_range_raises(self: Self, /) -> None:
-        value = MutableListSlot([1, 2])
-        with self.assertRaises(IndexError):
-            del value[5]
-
-
 if __name__ == "__main__":
     unittest.main()