More efficient pickling

Because pickling preserves object identity,
the behavior was still correct before,
it was just less efficient.

The new version is fully backwards compatible,
and is still able to deserialize data from v0.1.4.
There is a test to make sure this is true.

Fixes #5

Author: Techcable

mypy.ini

@@ -1,4 +1,3 @@
 [mypy]
 strict = true
 mypy_path = src
-

src/techcable/orderedset/_orderedset.py

@@ -259,6 +259,35 @@ def __get_pydantic_core_schema__(
             ),
         )
 
+    def __getstate__(self) -> Any:
+        """Efficiently pickles the elements of an OrderedSet."""
+        assert len(self._elements) == len(self._unique)
+        # format for v0.1.5
+        return self._elements.copy()
+
+    def __setstate__(self, state: Any) -> None:
+        """Restores the elements of an OrderedSet from the pickled representation."""
+        # init variables
+        self._unique = set()
+        self._elements = list()
+        # deserialize `state` - a poor man's `match`
+        elements: list[T]
+        if isinstance(state, list):
+            # format for v0.1.5 - list of elements
+            elements = state
+        elif isinstance(state, tuple) and len(state) == 2:
+            state_dict, state_slots = state
+            if state_dict is not None:
+                raise TypeError
+            # format for v0.1.4 - (None, dict(_elements=..., _unique=...))
+            elements = state_slots["_elements"]
+            if set(elements) != state_slots["_unique"]:
+                raise ValueError("Fields `_elements` and `_unique` must match")
+        else:
+            raise TypeError(f"Cannot unpickle from {type(state)}")
+        # set elements
+        self.update(elements)
+
     @classmethod
     def dedup(self, source: Iterable[T], /) -> Generator[T]:
         """A utility method to deduplicate the specified iterable,

tests/data/pickle/README.md

@@ -0,0 +1,4 @@
+# tests.data.pickle
+Contains data pickled using different versions of `techcable.orderedset`.
+
+This ensures

tests/data/pickle/example1-v0.1.4.dat

@@ -0,0 +1,32 @@
+import pickle
+from pathlib import Path
+
+import pytest
+
+from techcable.orderedset import OrderedSet
+
+
+def test_pickle_roundtrip():
+    original = OrderedSet([1, 2, 3, 4, 7, 1])
+    ser = pickle.dumps(original)
+    deser = pickle.loads(ser)
+    assert original == deser
+
+
+_LATEST_DATA_VERSION = "v0.1.5"
+"""The current version of the data being stored"""
+
+
+def _load_data(name: str, /, *, version: str) -> bytes:
+    return (Path(__file__).parent / f"data/pickle/{name}-{version}.dat").read_bytes()
+
+
+@pytest.mark.parametrize("version", ["v0.1.4"])
+@pytest.mark.parametrize("data", ["example1"])
+def test_unpickle_backwards_compat(version: str, data: str):
+    """Verify we can still unpickle from old versions"""
+    current_data = _load_data(data, version=_LATEST_DATA_VERSION)
+    old_data = _load_data(data, version=version)
+    current = pickle.loads(current_data)
+    old = pickle.loads(old_data)
+    assert old == current