A proxy whose __getattr__ delegates to self._client raises RecursionError when deep-copied — why?

## The lookup order that makes this possible `obj.x` does not call `__getattr__` first. It calls `type(obj).__getattribute__`, which walks data descriptors on the type, then the instance `__dict__`, then class attributes and non-data descriptors. Only when **all** of that fails does Python fall back to `__getattr__`, if the class defines one. So `__getattr__` is, by construction, the code that runs when a name is absent. A delegating implementation like this one: ```python def __getattr__(self, name): return getattr(self._client, name) ``` reads another attribute on `self` in order to answer. If `_client` is present, fine — normal lookup finds it in the instance dict and no fallback happens. If `_client` is **absent**, normal lookup fails, Python calls `__getattr__("_client")`, whose body reads `self._client` again, and the recursion has no base case. It ends in `RecursionError`, roughly a thousand frames later. ## Why the failure appears only on copy, pickle or unpickle The object is never blank in normal use, because `__init__` sets `_client` immediately. The copy and pickle machinery does not go through `__init__`: it constructs the new instance directly from the class, then restores state onto it. Between those two steps it **probes** the half-built object for hook names — `__setstate__` in particular — and that probe is a plain attribute lookup on an object whose instance dict is still empty. The probe misses, `__getattr__` is called, `self._client` is missing, and the loop starts. That is why the defect hides so well. The path is exercised by deep-copying a proxy, by pickling one to send it to another process, by a caching layer that snapshots configuration objects, or by any library that calls `hasattr()` on an object it did not construct. A regression pack of several hundred cases that only ever *uses* proxies, never copies them, passes every time. ## The production shape of it Take an ad-auction bidder that wraps each upstream connection in a delegating proxy. A code path deep-copies the bidder's configuration, which drags a proxy along with it. The copy blows up with `RecursionError`; the half-built proxy is discarded; and the connection it should have released is never closed, because `close()` on that half-built object would go through `__getattr__` too and raise again. One leaked descriptor per occurrence is invisible for hours and then is not: the process runs out of file descriptors while every functional test still passes. The lesson an interviewer is listening for is that an attribute-protocol loop does not merely raise — it raises *inside cleanup paths*, which is how it turns into a resource leak. ## Diagnosing it from the traceback A `RecursionError` whose collapsed traceback repeats two or three lines of your own code, one of which is a dunder method, is almost always a protocol loop rather than deep data. Note also that `hasattr()` only swallows `AttributeError`, so a `RecursionError` raised inside a delegating `__getattr__` propagates straight out of an innocent-looking `hasattr()` call in library code. ## Writing it safely Fetch the delegate in a way that cannot re-enter the hook: ```python class SafeProxy: def __init__(self, client): self._client = client def __getattr__(self, name): try: client = object.__getattribute__(self, "_client") except AttributeError: raise AttributeError(name) from None return getattr(client, name) ``` `object.__getattribute__` performs the normal lookup **without** the `__getattr__` fallback, so a missing `_client` produces a clean `AttributeError` and the recursion cannot start. Two cheaper guards work too, and are often combined with it: raise `AttributeError(name)` immediately when `name` is the delegate's own attribute, and raise it for any name that starts and ends with double underscores, so the protocol probes performed by copy, pickle, logging and interactive completion never reach the delegate at all. ## Related loops with the same shape The same trap reaches further than proxies. A `property` whose getter raises `AttributeError` — for any reason, including a genuine bug several calls deeper — is indistinguishable from a missing attribute as far as the lookup machinery is concerned, so Python falls back to `__getattr__`. If that hook then reads the same name, the two mechanisms feed each other and the real error is buried under a `RecursionError`. The defensive habit is to make sure a property getter never lets an `AttributeError` escape from code it merely calls: catch it and re-raise as something else, so the fallback path is never entered by accident. ## The sharper relative `__getattribute__` is easier still to break, because it intercepts **every** attribute access rather than only the failed ones. Any implementation that reads `self.anything` inside it recurses on the first call. The rule there is absolute: inside `__getattribute__`, reach for state only through `object.__getattribute__`. `__setattr__` has the mirror-image trap, and the mirror-image fix in `object.__setattr__`.