multicollections 0.2.0__tar.gz → 0.2.1__tar.gz

{multicollections-0.2.0 → multicollections-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multicollections
-Version: 0.2.0
+Version: 0.2.1
 Summary: Fully generic MultiDict class
 Project-URL: Homepage, https://github.com/gerlero/multicollections
 Project-URL: Repository, https://github.com/gerlero/multicollections

multicollections-0.2.1/multicollections/__init__.py

@@ -0,0 +1,315 @@
+"""Fully generic `MultiDict` class."""
+
+from __future__ import annotations
+
+import itertools
+import sys
+from typing import TypeVar
+
+if sys.version_info >= (3, 9):
+    from collections.abc import (
+        Iterable,
+        Iterator,
+        Mapping,
+        Sequence,
+    )
+else:
+    from typing import (
+        Iterable,
+        Iterator,
+        Mapping,
+        Sequence,
+    )
+
+from ._util import override
+from .abc import MutableMultiMapping, with_default
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+
+class MultiDict(MutableMultiMapping[_K, _V]):
+    """A fully generic dictionary that allows multiple values with the same key.
+
+    Preserves insertion order.
+    """
+
+    def __init__(
+        self, iterable: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (), **kwargs: _V
+    ) -> None:
+        """Create a MultiDict."""
+        self._items: list[tuple[_K, _V]] = []
+        self._key_indices: dict[_K, list[int]] = {}
+
+        # Batch initialization: collect all items first, then build indices once
+        if isinstance(iterable, Mapping):
+            self._items.extend((key, value) for key, value in iterable.items())
+        else:
+            self._items.extend((key, value) for key, value in iterable)
+
+        # Add kwargs items
+        self._items.extend((key, value) for key, value in kwargs.items())
+
+        # Build indices in one pass for better performance
+        if self._items:
+            self._rebuild_indices()
+
+    @override
+    @with_default
+    def getall(self, key: _K) -> list[_V]:
+        """Get all values for a key.
+
+        Raises a `KeyError` if the key is not found and no default is provided.
+        """
+        ret = [self._items[i][1] for i in self._key_indices.get(key, [])]
+        if not ret:
+            raise KeyError(key)
+        return ret
+
+    @override
+    def __setitem__(self, key: _K, value: _V) -> None:
+        """Set the value for a key.
+
+        Replaces the first value for a key if it exists; otherwise, it adds a new item.
+        Any other items with the same key are removed.
+        """
+        if key in self._key_indices:
+            # Key exists, replace first occurrence and remove others
+            indices = self._key_indices[key]
+            first_index = indices[0]
+
+            # Update the first occurrence
+            self._items[first_index] = (key, value)
+
+            if len(indices) > 1:
+                # Remove duplicates efficiently by marking items as None and filtering
+                for idx in indices[1:]:
+                    self._items[idx] = None
+
+                # Filter out None items and rebuild indices
+                self._items = [item for item in self._items if item is not None]
+                self._rebuild_indices()
+        else:
+            # Key doesn't exist, add it
+            self.add(key, value)
+
+    def _rebuild_indices(self) -> None:
+        """Rebuild the key indices after items list has been modified."""
+        self._key_indices = {}
+        for i, (key, _) in enumerate(self._items):
+            if key not in self._key_indices:
+                self._key_indices[key] = []
+            self._key_indices[key].append(i)
+
+    @override
+    def add(self, key: _K, value: _V) -> None:
+        """Add a new value for a key."""
+        index = len(self._items)
+        self._items.append((key, value))
+        if key not in self._key_indices:
+            self._key_indices[key] = []
+        self._key_indices[key].append(index)
+
+    @override
+    @with_default
+    def popone(self, key: _K) -> _V:
+        """Remove and return the first value for a key."""
+        if key not in self._key_indices:
+            raise KeyError(key)
+
+        indices = self._key_indices[key]
+        first_index = indices[0]
+        value = self._items[first_index][1]
+
+        # Mark the first item for removal
+        self._items[first_index] = None
+
+        # Filter out None items and rebuild indices
+        self._items = [item for item in self._items if item is not None]
+        self._rebuild_indices()
+
+        return value
+
+    @override
+    def __delitem__(self, key: _K) -> None:
+        """Remove all values for a key.
+
+        Raises a `KeyError` if the key is not found.
+        """
+        if key not in self._key_indices:
+            raise KeyError(key)
+
+        # Mark items for removal
+        indices_to_remove = self._key_indices[key]
+        for idx in indices_to_remove:
+            self._items[idx] = None
+
+        # Filter out None items and rebuild indices
+        self._items = [item for item in self._items if item is not None]
+        self._rebuild_indices()
+
+    @override
+    def __iter__(self) -> Iterator[_K]:
+        """Return an iterator over the keys, in insertion order.
+
+        Keys with multiple values will be yielded multiple times.
+        """
+        return (k for k, _ in self._items)
+
+    @override
+    def __len__(self) -> int:
+        """Return the total number of items."""
+        return len(self._items)
+
+    @override
+    def clear(self) -> None:
+        """Remove all items from the multi-mapping."""
+        self._items.clear()
+        self._key_indices.clear()
+
+    def _collect_update_items(
+        self,
+        all_items: list[tuple[_K, _V]],
+        existing_keys: set[_K],
+    ) -> tuple[dict[_K, list[_V]], list[tuple[_K, _V]]]:
+        """Separate items into updates and additions."""
+        updates_by_key = {}  # key -> list of values to replace with
+        additions = []  # list of (key, value) for new keys
+
+        for key, value in all_items:
+            if key in existing_keys:
+                if key not in updates_by_key:
+                    updates_by_key[key] = []
+                updates_by_key[key].append(value)
+            else:
+                additions.append((key, value))
+
+        return updates_by_key, additions
+
+    def _process_updates(self, updates_by_key: dict[_K, list[_V]]) -> None:
+        """Process updates efficiently by batch removing and adding."""
+        # Mark items for removal that need to be replaced
+        items_to_remove = set()
+        for key in updates_by_key:
+            items_to_remove.update(self._key_indices[key])
+
+        # Mark items for removal
+        for idx in items_to_remove:
+            self._items[idx] = None
+
+        # Filter out None items
+        self._items = [item for item in self._items if item is not None]
+
+        # Add updated items (all values for each key)
+        for key, values in updates_by_key.items():
+            for value in values:
+                self._items.append((key, value))
+
+    @override
+    def update(
+        self,
+        other: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (),
+        **kwargs: _V,
+    ) -> None:
+        """Update the multi-mapping with items from another object.
+
+        This replaces existing values for keys found in the other object.
+        This is optimized for batch operations.
+        """
+        # Collect all items first
+        items = other.items() if isinstance(other, Mapping) else other
+        items = itertools.chain(items, kwargs.items())
+        all_items = list(items)
+
+        if not all_items:
+            return
+
+        # Get existing keys once for efficiency
+        existing_keys = set(self._key_indices.keys())
+
+        # Separate items into updates and additions
+        updates_by_key, additions = self._collect_update_items(all_items, existing_keys)
+
+        # Process updates efficiently
+        if updates_by_key:
+            self._process_updates(updates_by_key)
+
+        # Add new items
+        if additions:
+            self._items.extend(additions)
+
+        # Rebuild indices once at the end
+        if updates_by_key or additions:
+            self._rebuild_indices()
+
+    @override
+    def merge(
+        self,
+        other: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (),
+        **kwargs: _V,
+    ) -> None:
+        """Merge another object into the multi-mapping.
+
+        Keys from `other` that already exist in the multi-mapping will not be added.
+        This is optimized for batch operations.
+        """
+        # Get existing keys once for efficiency
+        existing_keys = set(self._key_indices.keys())
+
+        # Collect all items and filter out existing keys
+        items = other.items() if isinstance(other, Mapping) else other
+        items = itertools.chain(items, kwargs.items())
+        new_items = [(key, value) for key, value in items if key not in existing_keys]
+
+        if not new_items:
+            return
+
+        # Add all items to the list at once
+        start_index = len(self._items)
+        self._items.extend(new_items)
+
+        # Update indices incrementally for better performance
+        for i, (key, _) in enumerate(new_items, start_index):
+            if key not in self._key_indices:
+                self._key_indices[key] = []
+            self._key_indices[key].append(i)
+
+    @override
+    def extend(
+        self,
+        other: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (),
+        **kwargs: _V,
+    ) -> None:
+        """Extend the multi-mapping with items from another object.
+
+        This is optimized for batch operations to avoid rebuilding indices
+        multiple times.
+        """
+        # Collect all new items first
+        items = other.items() if isinstance(other, Mapping) else other
+        items = itertools.chain(items, kwargs.items())
+        new_items = list(items)
+
+        if not new_items:
+            return
+
+        # Add all items to the list at once
+        start_index = len(self._items)
+        self._items.extend(new_items)
+
+        # Update indices incrementally for better performance
+        for i, (key, _) in enumerate(new_items, start_index):
+            if key not in self._key_indices:
+                self._key_indices[key] = []
+            self._key_indices[key].append(i)
+
+    def copy(self) -> MultiDict[_K, _V]:
+        """Return a shallow copy of the MultiDict."""
+        new_md = MultiDict.__new__(MultiDict)
+        new_md._items = self._items.copy()  # noqa: SLF001
+        new_md._key_indices = {k: v.copy() for k, v in self._key_indices.items()}  # noqa: SLF001
+        return new_md
+
+    def __repr__(self) -> str:
+        """Return a string representation of the MultiDict."""
+        return f"{self.__class__.__name__}({list(self._items)!r})"

multicollections-0.2.1/multicollections/_util.py

@@ -0,0 +1,16 @@
+import sys
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    try:
+        from typing_extensions import override
+    except ImportError:  # pragma: nocover
+        if TYPE_CHECKING:
+            raise
+
+        def override(func: Callable) -> Callable:
+            """Fallback override decorator that does nothing."""
+            return func

{multicollections-0.2.0 → multicollections-0.2.1}/multicollections/abc.py

@@ -8,7 +8,7 @@ import itertools
 import sys
 from abc import abstractmethod
 from collections import defaultdict
-from typing import Generic, TypeVar
+from typing import TYPE_CHECKING, Generic, TypeVar, overload
 
 if sys.version_info >= (3, 9):
     from collections.abc import (
@@ -33,14 +33,21 @@ else:
         Sequence,
     )
 
+if TYPE_CHECKING:  # pragma: no cover
+    from typing import Protocol
+
+from ._util import override
+
 _K = TypeVar("_K")
 _V = TypeVar("_V")
 _D = TypeVar("_D")
+_Self = TypeVar("_Self")
 
 
 class MultiMappingView(MappingView, Collection):
     """Base class for MultiMapping views."""
 
+    @override
     def __init__(self, mapping: MultiMapping[_K, _V]) -> None:
         """Initialize the view with the given mapping."""
         super().__init__(mapping)
@@ -49,10 +56,12 @@ class MultiMappingView(MappingView, Collection):
 class KeysView(MultiMappingView):
     """View for the keys in a MultiMapping."""
 
-    def __contains__(self, key: _K) -> bool:
+    @override
+    def __contains__(self, key: object) -> bool:
         """Check if the key is in the mapping."""
         return key in self._mapping
 
+    @override
     def __iter__(self) -> Iterator[_K]:
         """Return an iterator over the keys."""
         return iter(self._mapping)
@@ -61,17 +70,22 @@ class KeysView(MultiMappingView):
 class ItemsView(MultiMappingView):
     """View for the items (key-value pairs) in a MultiMapping."""
 
-    def __contains__(self, item: tuple[_K, _V]) -> bool:
+    @override
+    def __contains__(self, item: object) -> bool:
         """Check if the item is in the mapping."""
-        key, value = item
+        try:
+            key, value = item  # ty: ignore[not-iterable]
+        except TypeError:
+            return False
         try:
             return value in self._mapping.getall(key)
         except KeyError:
             return False
 
+    @override
     def __iter__(self) -> Iterator[tuple[_K, _V]]:
         """Return an iterator over the items (key-value pairs)."""
-        counts = defaultdict(int)
+        counts: defaultdict[_K, int] = defaultdict(int)
         for k in self._mapping:
             yield (k, self._mapping.getall(k)[counts[k]])
             counts[k] += 1
@@ -80,10 +94,12 @@ class ItemsView(MultiMappingView):
 class ValuesView(MultiMappingView):
     """View for the values in a MultiMapping."""
 
-    def __contains__(self, value: _V) -> bool:
+    @override
+    def __contains__(self, value: object) -> bool:
         """Check if the value is in the mapping."""
         return value in iter(self)
 
+    @override
     def __iter__(self) -> Iterator[_V]:
         """Return an iterator over the values."""
         yield from (v for _, v in self._mapping.items())
@@ -95,15 +111,30 @@ class _NoDefault:
 
 _NO_DEFAULT = _NoDefault()
 
+if TYPE_CHECKING:  # pragma: no cover
+
+    class _CallableWithDefault(Protocol[_Self, _K, _V, _D]):
+        @overload
+        def __call__(self: _Self, key: _K) -> _V: ...
+
+        @overload
+        def __call__(self: _Self, key: _K, default: _D) -> _V | _D: ...
+
 
 def with_default(
-    meth: Callable[[MultiMappingView[_K, _V], _K], _V],
-) -> Callable[[MultiMappingView[_K, _V], _K, _D], _V | _D]:
+    meth: Callable[[_Self, _K], _V],
+) -> _CallableWithDefault[_Self, _K, _V, _D]:
     """Add a default value argument to a method that can raise a `KeyError`."""
 
+    @overload
+    def wrapper(self: _Self, key: _K) -> _V: ...  # pragma: no cover
+
+    @overload
+    def wrapper(self: _Self, key: _K, default: _D) -> _V | _D: ...  # pragma: no cover
+
     @functools.wraps(meth)
     def wrapper(
-        self: MultiMappingView[_K, _V], key: _K, default: _D | _NoDefault = _NO_DEFAULT
+        self: _Self, key: _K, default: _D | _NoDefault = _NO_DEFAULT
     ) -> _V | _D:
         try:
             return meth(self, key)
@@ -152,6 +183,7 @@ class MultiMapping(Mapping[_K, _V], Generic[_K, _V]):
         """
         return self.getall(key)[0]
 
+    @override
     def __getitem__(self, key: _K) -> _V:
         """Get the first value for a key.
 
@@ -159,14 +191,17 @@ class MultiMapping(Mapping[_K, _V], Generic[_K, _V]):
         """
         return self.getone(key)
 
+    @override
     def keys(self) -> KeysView[_K]:
         """Return a view of the keys in the MultiMapping."""
         return KeysView(self)
 
+    @override
     def items(self) -> ItemsView[_K, _V]:
         """Return a view of the items (key-value pairs) in the MultiMapping."""
         return ItemsView(self)
 
+    @override
     def values(self) -> ValuesView[_V]:
         """Return a view of the values in the MultiMapping."""
         return ValuesView(self)
@@ -226,6 +261,7 @@ class MutableMultiMapping(MultiMapping[_K, _V], MutableMapping[_K, _V]):
         value = self.popone(key)
         return key, value
 
+    @override
     def __delitem__(self, key: _K) -> None:
         """Remove all values for a key.
 
@@ -233,11 +269,13 @@ class MutableMultiMapping(MultiMapping[_K, _V], MutableMapping[_K, _V]):
         """
         self.popall(key)
 
+    @override
     def clear(self) -> None:
         """Remove all items from the multi-mapping."""
         for key in set(self.keys()):
             self.popall(key)
 
+    @override
     def extend(
         self,
         other: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (),
@@ -249,6 +287,7 @@ class MutableMultiMapping(MultiMapping[_K, _V], MutableMapping[_K, _V]):
         for key, value in items:
             self.add(key, value)
 
+    @override
     def merge(
         self,
         other: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (),
@@ -265,6 +304,7 @@ class MutableMultiMapping(MultiMapping[_K, _V], MutableMapping[_K, _V]):
             if key not in existing_keys:
                 self.add(key, value)
 
+    @override
     def update(
         self,
         other: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (),

{multicollections-0.2.0 → multicollections-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "multicollections"
-version = "0.2.0"
+version = "0.2.1"
 authors = [
     { name = "Gabriel S. Gerlero", email = "ggerlero@cimec.unl.edu.ar" },
 ]
@@ -31,9 +31,13 @@ requires-python = ">=3.7"
 
 [dependency-groups]
 lint = ["ruff"]
-typing = ["ty; python_version>='3.8'"]
+typing = [
+    "ty; python_version>='3.8'",
+    "typing_extensions >= 4.4.0; python_version<'3.12'"
+]
 test = [
     "multidict>=6,<7",
+    "typing_extensions >= 4.4.0; python_version<'3.12'",
     "pytest>=7,<9",
     "pytest-cov"
 ]

{multicollections-0.2.0 → multicollections-0.2.1}/tests/minimalimpl.py

@@ -18,6 +18,7 @@ else:
         Sequence,
     )
 
+from multicollections._util import override
 from multicollections.abc import MutableMultiMapping, with_default
 
 _K = TypeVar("_K")
@@ -38,6 +39,7 @@ class ListMultiDict(MutableMultiMapping[_K, _V]):
         for key, value in kwargs.items():
             self._items.append((key, value))
 
+    @override
     @with_default
     def getall(self, key: _K) -> list[_V]:
         ret = [v for k, v in self._items if k == key]
@@ -45,6 +47,7 @@ class ListMultiDict(MutableMultiMapping[_K, _V]):
             raise KeyError(key)
         return ret
 
+    @override
     def __setitem__(self, key: _K, value: _V) -> None:
         replaced: int | None = None
         for i, (k, _) in enumerate(self._items):
@@ -62,9 +65,11 @@ class ListMultiDict(MutableMultiMapping[_K, _V]):
         else:
             self._items.append((key, value))
 
+    @override
     def add(self, key: _K, value: _V) -> None:
         self._items.append((key, value))
 
+    @override
     @with_default
     def popone(self, key: _K) -> _V:
         for i, (k, v) in enumerate(self._items):
@@ -73,8 +78,10 @@ class ListMultiDict(MutableMultiMapping[_K, _V]):
                 return v
         raise KeyError(key)
 
+    @override
     def __iter__(self) -> Iterator[_K]:
         return (k for k, _ in self._items)
 
+    @override
     def __len__(self) -> int:
         return len(self._items)

{multicollections-0.2.0 → multicollections-0.2.1}/tests/test_multicollections.py

@@ -213,6 +213,9 @@ def test_items_view_contains(cls: type[MutableMultiMapping]) -> None:
     assert ("c", 1) not in items  # Key doesn't exist
     assert ("b", 1) not in items  # Wrong value for existing key
 
+    # Test different type
+    assert None not in items
+
     # Test empty case
     empty_md = cls()
     empty_items = empty_md.items()
@@ -267,6 +270,8 @@ def test_contains(cls: type[MutableMultiMapping]) -> None:
     assert "a" in md
     assert "b" in md
     assert "missing" not in md
+    if cls is not multidict.MultiDict or sys.version_info >= (3, 9):
+        assert None not in md
 
     # Test with empty MultiDict
     empty_md = cls()
@@ -805,3 +810,209 @@ def test_edge_cases_multidict_specific() -> None:
 
     assert len(md._items) == 2  # b and c  # noqa: SLF001
     assert md._key_indices["c"] == [1]  # Only one index for c  # noqa: SLF001
+
+
+@pytest.mark.parametrize("cls", [MultiDict, multidict.MultiDict])
+def test_copy_method(cls: type[MultiDict | multidict.MultiDict]) -> None:
+    """Test copy() method."""
+    # Test copying empty MultiDict
+    empty_md = cls()
+    empty_copy = empty_md.copy()
+    assert len(empty_copy) == 0
+    assert list(empty_copy.items()) == []
+    assert empty_md is not empty_copy  # Different objects
+
+    # Test copying MultiDict with single item
+    single_md = cls([("a", 1)])  # ty: ignore [too-many-positional-arguments]
+    single_copy = single_md.copy()
+    assert len(single_copy) == 1
+    assert list(single_copy.items()) == [("a", 1)]
+    assert single_md is not single_copy  # Different objects
+
+    # Test copying MultiDict with multiple items including duplicates
+    md = cls([("a", 1), ("b", 2), ("a", 3), ("c", 4)])  # ty: ignore [too-many-positional-arguments]
+    copied = md.copy()
+
+    # Test that content is identical
+    assert len(copied) == len(md)
+    assert list(copied.items()) == list(md.items())
+    assert list(copied.keys()) == list(md.keys())
+    assert list(copied.values()) == list(md.values())
+
+    # Test that duplicate keys are preserved
+    assert copied.getall("a") == md.getall("a") == [1, 3]
+
+    # Test that they are different objects
+    assert md is not copied
+
+    # Test that changes to original don't affect copy
+    md.add("d", 5)
+    assert len(md) == 5
+    assert len(copied) == 4
+    assert "d" not in copied
+
+    # Test that changes to copy don't affect original
+    copied.add("e", 6)
+    assert len(copied) == 5
+    assert len(md) == 5
+    assert "e" not in md
+
+    # Test that copy() creates a shallow copy (values are not deep copied)
+    value_list = [1, 2, 3]
+    md_with_mutable = cls([("key", value_list)])  # ty: ignore [too-many-positional-arguments]
+    copied_with_mutable = md_with_mutable.copy()
+
+    # The list should be the same object (shallow copy)
+    assert copied_with_mutable["key"] is value_list
+    assert md_with_mutable["key"] is value_list
+
+
+# Additional tests for uncovered lines
+def test_empty_init_no_rebuild() -> None:
+    """Test that empty MultiDict initialization doesn't call _rebuild_indices."""
+    # This tests line 53-54: if self._items: and the else branch
+    md = MultiDict()
+    assert len(md._items) == 0  # noqa: SLF001
+    assert len(md._key_indices) == 0  # noqa: SLF001
+
+
+def test_update_with_empty_input() -> None:
+    """Test update with empty input to cover early return."""
+    # This tests line 214-215: if not all_items: return
+    md = MultiDict([("a", 1)])
+    md.update()  # Empty input
+    assert len(md) == 1
+    assert md["a"] == 1
+
+    md.update([])  # Empty list
+    assert len(md) == 1
+    assert md["a"] == 1
+
+
+def test_merge_with_empty_input() -> None:
+    """Test merge with empty input to cover early return."""
+    # This tests line 253-254: if not new_items: return
+    md = MultiDict([("a", 1)])
+    md.merge()  # Empty input
+    assert len(md) == 1
+    assert md["a"] == 1
+
+    md.merge([])  # Empty list
+    assert len(md) == 1
+    assert md["a"] == 1
+
+
+def test_extend_with_empty_input() -> None:
+    """Test extend with empty input to cover early return."""
+    # This tests line 281-282: if not new_items: return
+    md = MultiDict([("a", 1)])
+    md.extend()  # Empty input
+    assert len(md) == 1
+    assert md["a"] == 1
+
+    md.extend([])  # Empty list
+    assert len(md) == 1
+    assert md["a"] == 1
+
+
+def test_merge_all_existing_keys() -> None:
+    """Test merge where all keys already exist."""
+    # This tests the case where new_items becomes empty after filtering
+    md = MultiDict([("a", 1), ("b", 2)])
+    md.merge([("a", 999), ("b", 888)])  # All keys exist, should be filtered out
+    assert len(md) == 2
+    assert md["a"] == 1  # Should remain unchanged
+    assert md["b"] == 2  # Should remain unchanged
+
+
+def test_merge_existing_key_in_indices() -> None:
+    """Test merge with key that already exists in indices."""
+    # This tests line 262-263: if key not in self._key_indices
+    md = MultiDict([("a", 1)])
+    existing_keys = set(md._key_indices.keys())  # noqa: SLF001
+    assert "a" in existing_keys
+
+    # Since merge filters out existing keys, we test the else branch
+    # by adding a new key
+    md.merge([("b", 2)])
+    assert "b" in md._key_indices  # noqa: SLF001
+    assert md["b"] == 2
+
+
+def test_extend_existing_key_in_indices() -> None:
+    """Test extend with key that already exists in indices."""
+    # This tests line 290-291: if key not in self._key_indices
+    md = MultiDict([("a", 1)])
+
+    # Extend with existing key - should add to existing key's index list
+    md.extend([("a", 2)])
+    assert len(md._key_indices["a"]) == 2  # noqa: SLF001
+    assert md._key_indices["a"] == [0, 1]  # noqa: SLF001
+
+
+def test_update_only_updates_no_additions() -> None:
+    """Test update with only existing keys (no new keys)."""
+    # This tests line 228-229: if additions: branch when additions is empty
+    md = MultiDict([("a", 1), ("b", 2)])
+    md.update([("a", 999), ("b", 888)])  # Only existing keys
+
+    assert len(md) == 2
+    assert md["a"] == 999
+    assert md["b"] == 888
+
+
+def test_update_only_additions_no_updates() -> None:
+    """Test update with only new keys (no existing keys)."""
+    # This tests line 224-225: if updates_by_key: branch when updates_by_key is empty
+    md = MultiDict([("a", 1)])
+    md.update([("b", 2), ("c", 3)])  # Only new keys
+
+    assert len(md) == 3
+    assert md["a"] == 1  # Original unchanged
+    assert md["b"] == 2
+    assert md["c"] == 3
+
+
+def test_init_with_no_items_and_no_kwargs() -> None:
+    """Test initialization with completely empty input."""
+    # This tests the case where _items remains empty after all initialization
+    md = MultiDict(())  # Empty tuple
+    assert len(md._items) == 0  # noqa: SLF001
+    assert len(md._key_indices) == 0  # noqa: SLF001
+
+
+def test_collect_update_items_edge_cases() -> None:
+    """Test _collect_update_items helper method edge cases."""
+    md = MultiDict([("a", 1)])
+
+    # Test with empty all_items
+    updates, additions = md._collect_update_items([], set())  # noqa: SLF001
+    assert updates == {}
+    assert additions == []
+
+    # Test with all new keys
+    updates, additions = md._collect_update_items([("b", 2), ("c", 3)], set())  # noqa: SLF001
+    assert updates == {}
+    assert additions == [("b", 2), ("c", 3)]
+
+    # Test with all existing keys
+    updates, additions = md._collect_update_items([("a", 999)], {"a"})  # noqa: SLF001
+    assert updates == {"a": [999]}
+    assert additions == []
+
+
+def test_process_updates_edge_cases() -> None:
+    """Test _process_updates helper method edge cases."""
+    md = MultiDict([("a", 1), ("b", 2), ("a", 3)])
+    original_len = len(md)
+
+    # Test with empty updates
+    md._process_updates({})  # noqa: SLF001
+    assert len(md) == original_len  # Should remain unchanged
+
+    # Test with single key update - need to rebuild indices after _process_updates
+    md = MultiDict([("a", 1), ("b", 2), ("a", 3)])
+    md._process_updates({"a": [999]})  # noqa: SLF001
+    md._rebuild_indices()  # _process_updates doesn't rebuild indices  # noqa: SLF001
+    assert md["a"] == 999
+    assert md["b"] == 2

multicollections-0.2.0/multicollections/__init__.py

@@ -1,156 +0,0 @@
-"""Fully generic `MultiDict` class."""
-
-from __future__ import annotations
-
-import sys
-from typing import TypeVar
-
-if sys.version_info >= (3, 9):
-    from collections.abc import (
-        Iterable,
-        Iterator,
-        Mapping,
-        Sequence,
-    )
-else:
-    from typing import (
-        Iterable,
-        Iterator,
-        Mapping,
-        Sequence,
-    )
-
-from .abc import MutableMultiMapping, with_default
-
-_K = TypeVar("_K")
-_V = TypeVar("_V")
-
-
-class MultiDict(MutableMultiMapping[_K, _V]):
-    """A fully generic dictionary that allows multiple values with the same key.
-
-    Preserves insertion order.
-    """
-
-    def __init__(
-        self, iterable: Mapping[_K, _V] | Iterable[Sequence[_K | _V]] = (), **kwargs: _V
-    ) -> None:
-        """Create a MultiDict."""
-        self._items: list[tuple[_K, _V]] = []
-        self._key_indices: dict[_K, list[int]] = {}
-        if isinstance(iterable, Mapping):
-            for key, value in iterable.items():
-                self._add_item(key, value)
-        else:
-            for key, value in iterable:
-                self._add_item(key, value)
-        for key, value in kwargs.items():
-            self._add_item(key, value)
-
-    def _add_item(self, key: _K, value: _V) -> None:
-        """Add an item and update the key index."""
-        index = len(self._items)
-        self._items.append((key, value))
-        if key not in self._key_indices:
-            self._key_indices[key] = []
-        self._key_indices[key].append(index)
-
-    @with_default
-    def getall(self, key: _K) -> list[_V]:
-        """Get all values for a key.
-
-        Raises a `KeyError` if the key is not found and no default is provided.
-        """
-        ret = [self._items[i][1] for i in self._key_indices.get(key, [])]
-        if not ret:
-            raise KeyError(key)
-        return ret
-
-    def __setitem__(self, key: _K, value: _V) -> None:
-        """Set the value for a key.
-
-        Replaces the first value for a key if it exists; otherwise, it adds a new item.
-        Any other items with the same key are removed.
-        """
-        if key in self._key_indices:
-            # Key exists, replace first occurrence and remove others
-            indices = self._key_indices[key]
-            first_index = indices[0]
-
-            # Update the first occurrence
-            self._items[first_index] = (key, value)
-
-            if len(indices) > 1:
-                # Remove duplicates efficiently by marking items as None and filtering
-                for idx in indices[1:]:
-                    self._items[idx] = None
-
-                # Filter out None items and rebuild indices
-                self._items = [item for item in self._items if item is not None]
-                self._rebuild_indices()
-        else:
-            # Key doesn't exist, add it
-            self._add_item(key, value)
-
-    def _rebuild_indices(self) -> None:
-        """Rebuild the key indices after items list has been modified."""
-        self._key_indices = {}
-        for i, (key, _) in enumerate(self._items):
-            if key not in self._key_indices:
-                self._key_indices[key] = []
-            self._key_indices[key].append(i)
-
-    def add(self, key: _K, value: _V) -> None:
-        """Add a new value for a key."""
-        self._add_item(key, value)
-
-    @with_default
-    def popone(self, key: _K) -> _V:
-        """Remove and return the first value for a key."""
-        if key not in self._key_indices:
-            raise KeyError(key)
-
-        indices = self._key_indices[key]
-        first_index = indices[0]
-        value = self._items[first_index][1]
-
-        # Mark the first item for removal
-        self._items[first_index] = None
-
-        # Filter out None items and rebuild indices
-        self._items = [item for item in self._items if item is not None]
-        self._rebuild_indices()
-
-        return value
-
-    def __delitem__(self, key: _K) -> None:
-        """Remove all values for a key.
-
-        Raises a `KeyError` if the key is not found.
-        """
-        if key not in self._key_indices:
-            raise KeyError(key)
-
-        # Mark items for removal
-        indices_to_remove = self._key_indices[key]
-        for idx in indices_to_remove:
-            self._items[idx] = None
-
-        # Filter out None items and rebuild indices
-        self._items = [item for item in self._items if item is not None]
-        self._rebuild_indices()
-
-    def __iter__(self) -> Iterator[_K]:
-        """Return an iterator over the keys, in insertion order.
-
-        Keys with multiple values will be yielded multiple times.
-        """
-        return (k for k, _ in self._items)
-
-    def __len__(self) -> int:
-        """Return the total number of items."""
-        return len(self._items)
-
-    def __repr__(self) -> str:
-        """Return a string representation of the MultiDict."""
-        return f"{self.__class__.__name__}({list(self._items)!r})"