How does it fare with a plain queue.Queue? does it fail as well?

Just tested it and it appears to work as intended.

from queue import Queue

class Foo:
    """
    Any old object
    """
    def __init__(self, var: int):
        self._var = var

    @property
    def var(self) -> int:
        return self._var

class FooWrapper:
    """
    Wrapper class to expose underlying object attrs
    """
    def __init__(self, foo: Foo):
        self.foo = foo

    def __getattr__(self, name):
        return getattr(self.foo, name)

if __name__=="__main__":
    queue = Queue()
    foo = Foo(2)
    foo_wrapper = FooWrapper(foo)
    queue.put(foo_wrapper)
    message_wrapper = queue.get()
    print(f"{message_wrapper.var}")
>>>
2

This happens during unpickling. Here's a simplified reproducer without multiprocessing.Queue:

import pickle

class Wrapper:
    def __init__(self, x):
        self.x = x

    def __getattr__(self, name):
        return getattr(self.x, name)

b = pickle.dumps(Wrapper("foo"))
pickle.loads(b)  # <-- recursion here

The recursion happens during this call of PyObject_GetOptionalAttr, which is checking for the existence of __setstate__ on the instance being built. This calls __getattr__, and since the instance dict hasn't been populated yet, the lookup of self.x inside __getattr__ results in an infinitely recursing __getattr__ call.

• Does it also affect the Python implementation of pickle?
• Do you want to make a PR for that?

Ya, the Python implementation is also affected (recurses in the "same spot" here).

However, looking at the pickle docs, this seems to be expected behavior. The docs have this warning about relying on __init__ being called before __getattr__ (as the code above does):

At unpickling time, some methods like __getattr__(), __getattribute__(), or __setattr__() may be called upon the instance. In case those methods rely on some internal invariant being true, the type should implement __new__() to establish such an invariant, as __init__() is not called when unpickling an instance.

So, I think this can be considered a bug in the user code and not something CPython needs to fix.

Indeed, thanks for pointing out the docs. Is there a way to determine which methods can be called during unpickling (by default)? if not, let's close this issue; otherwise, let's improve the wording in the docs (to me, it seems as if we say "we know of some methods but others can also be called so up to you to find which ones")