__getstate__ and __setstate__

## Why the default breaks With no hooks defined, an instance pickles its `__dict__`, and every value in that dict must be picklable in turn. A synchronisation primitive is not: it wraps an operating-system object with no meaningful serialised form, and `pickle.dumps` refuses with `TypeError: cannot pickle '_thread.lock' object`. Note *when* that happens -- at dump time, not at load time. Files, sockets, database connections, live generators and compiled callables fail the same way, and a cache of results may pickle fine yet be pure waste in the stream. ## The idiom ```python import pickle import threading class FlagCache: def __init__(self, flags): self.flags = flags self.lock = threading.Lock() def __getstate__(self): state = self.__dict__.copy() # copy first del state["lock"] # then drop the unpicklable part return state def __setstate__(self, state): self.__dict__.update(state) # restore what was stored self.lock = threading.Lock() # rebuild what was not ``` Three things carry the answer. First, `__getstate__` returns a *filtered copy* of the state. Second, `__setstate__` merges what was stored. Third -- and this is the part candidates forget -- `__setstate__` recreates the dropped attribute, because nothing else will: the unpickler allocates a blank instance and never calls `__init__`. ## Copy, do not mutate `self.__dict__` is the object's live attribute mapping. Writing `state = self.__dict__` and then `del state["lock"]` deletes the lock from the running instance -- pickling an object quietly breaks it. The same trap applies to the modern spelling: since 3.11 you can write `state = super().__getstate__()`, but for an ordinary class that returns the live `__dict__` itself, not a copy, so it must be copied before you edit it. On 3.10 and earlier the `super()` call does not exist at all and `self.__dict__.copy()` is the only spelling. ## Rebuild versus reconnect A fresh lock is the easy case: locks carry no identity worth preserving, and the restored object simply gets an unheld one. Other resources demand a decision rather than a reflex: * **Connections and file handles.** Reopening eagerly inside `__setstate__` makes unpickling do I/O, which can fail in a context where nothing is prepared to handle it. Storing enough to reconnect -- a path, a DSN, an offset -- and opening lazily on first use is usually the better shape. * **Derived caches.** Rebuilding is cheap and correct; storing them bloats the stream and risks staleness, since the cached values were computed against inputs that may have moved on. * **Held state.** If the lock was held or a transaction was open at dump time, there is nothing honest to restore. Do not pickle mid-operation objects; pickle them at rest. ## Ownership after the round trip A restored object is a genuinely separate object with genuinely separate primitives. Two processes that unpickle the same bytes each get their own lock, and those locks coordinate nothing with each other -- they only ever protect the object each one holds. Candidates who imagine a lock "reconnects" to some shared original have the model wrong, and interviewers probe exactly there. ## Testing it The round trip belongs in a unit test, not in production discovery. `pickle.loads(pickle.dumps(obj))` and then assert on the attributes that matter: that the rebuilt attribute exists, that it is a distinct object from the original's, and that the restored instance passes whatever invariant check `__init__` would have guaranteed. That test is what catches the very common half-fix in which someone writes `__getstate__` to make the dump succeed and forgets `__setstate__` entirely -- a change that turns a loud `TypeError` at dump time into a quiet `AttributeError` much later, at first use of the missing attribute. ## When there is nothing to drop Do not add these hooks by reflex. If every attribute is plain data, the default state is correct, faster to reason about, and one less thing to keep in step with the constructor. The hooks earn their place precisely when the object owns something the byte stream cannot carry.