Keep UniqueList, the casted dicts and SliceableDeque consistent

[wolph]

Builds on #51 by @shkyyy18, whose commit is the first one on this branch. That PR fixes indexed assignment in UniqueList. This one applies the same rule to every other way the containers can change: a class that subclasses a builtin has to cover every route into it.

The branch also contains #53, so the test hooks pass on any machine. Merge #53 first, or merge this and #53 is included.

UniqueList

UniqueList tracks membership in a set next to the list. Only append, insert, __setitem__ and __delitem__ updated that set, so the two drifted apart:

values = UniqueList(1, 2, 3, on_duplicate='raise')
values[0:2] = [8, 9]
1 in values        # True, although the list is [8, 9, 3]

values = UniqueList(1, 2)
values.pop()
values.append(2)   # ignored, although the list is [1]

values = UniqueList(1, 2)
values.extend([2, 2])
values             # [1, 2, 2, 2]

• Slice assignment stores the values first and updates the membership afterwards. It accepts one-shot iterables, lets a slice reuse the values it replaces, and rejects a slice that repeats a value.
• extend, += and *= follow on_duplicate. In raise mode extend checks every value before it changes the list.
• pop, remove and clear release the values they remove. A failed insert no longer reserves its value.
• in answers for an unhashable value the way a list does.
• copy.copy and copy.deepcopy returned an empty list in ignore mode and raised in raise mode. Both now return a working copy.

CastedDict and LazyCastedDict

values = CastedDict(int, int, {'1': '2'})
pickle.loads(pickle.dumps(values))   # AttributeError: no attribute '_value_cast'
values.setdefault('3', '4')          # stored as '3': '4', not cast
values |= {'5': '6'}                 # stored as '5': '6', not cast
CastedDict(None, None, {'a': 1}, a=2)  # {'a': 1}, dict gives {'a': 2}

• pickle restored the items through __setitem__ before the casts were back, so protocol 2 and up could not be loaded. copy did it after and cast every value twice. The raw items now travel in the state.
• setdefault and |= go through the casts.
• update and the constructor apply keyword arguments last, like dict.

SliceableDeque

• d == [1, 2] and d != [1, 2] were both True. __ne__ now follows __eq__.
• == against a set is False when an item cannot be hashed. It raised TypeError.

Compatibility

Checked against the released 4.0.1 in five adversarial rounds. They found regressions in earlier versions of this branch, all fixed here and pinned by tests:

• A subclass that sets on_duplicate on the class keeps its policy.
• A subclass with __slots__ keeps its slot values through pickle and copy.
• pop, remove, del and index assignment do not raise for a value whose hash changed after it was added.
• A subclass with its own __setstate__ or __reduce_ex__, or with a mixin that brings one, pickles and copies as it did.
• An empty casted dict is pickled in the form that 4.0.1 can load.
• UniqueList.remove is one list operation, and insert, index assignment and slice assignment reserve the membership before they write. Under threads the list is never worse off than in 4.0.1. A stress run with six threads showed about 36000 duplicates for the first version of insert and none now.

The last round re-ran every reproduction and harness from all rounds and found no line that differs from the expected outcome.

Intended behaviour changes:

• UniqueList.extend and += no longer add duplicates and *= no longer repeats items. The documentation already promised this for extend.
• Slice assignment is more permissive for values the slice itself replaces, and stricter for a slice that repeats a value.
• setdefault and |= on the casted dicts cast what they store. A None default is stored as it is.
• A LazyCastedDict casts a key once when it stores it. It cast the key twice, which only shows for a cast that is not idempotent.
• A copy of a LazyCastedDict keeps the raw values, where it stored the cast ones.
• When the same key is passed to a casted dict both in the mapping and as a keyword, the keyword wins.
• SliceableDeque != equal_list is False.
• The DictUpdateArgs alias no longer lists an iterable of mappings. That shape raised or stored a key as the value. Nothing changes at runtime.

Pickles written by 4.0.1 still load, including casted dict pickles on protocol 2 and up that 4.0.1 itself could not read back. The released 4.0.1 test_containers.py passes unchanged against this branch.

Left alone on purpose, because the change would be visible to working code:

• LazyCastedDict.get, pop and popitem return the stored value without casting it.
• A slice of a bounded SliceableDeque has no maxlen.
• UniqueList.remove with an argument that is equal to more than one item can release the wrong member. Releasing the stored item needs two list operations, which is not safe between threads.
• UniqueList.extend appends value by value, so a batch is not contiguous when other threads extend at the same time.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, add credits to your account and enable them for code reviews in your settings.