ObjectProxy objects are not copyable

I was trying to use ObjectProxy in a context where the object in question sometimes gets copied by copy.copy, e.g.:

from wrapt import ObjectProxy
import copy
print(copy.copy(ObjectProxy(1)))

which raises an exception:

ValueError                                Traceback (most recent call last)
<ipython-input-29-184d66a435a2> in <module>()
----> 1 print(copy.copy(ObjectProxy(1)))

/Users/ryan/.pyenv/versions/3.5.2/lib/python3.5/copy.py in copy(x)
    103                 raise Error("un(shallow)copyable object of type %s" % cls)
    104
--> 105     return _reconstruct(x, rv, 0)
    106
    107

/Users/ryan/.pyenv/versions/3.5.2/lib/python3.5/copy.py in _reconstruct(x, info, deep, memo)
    296         if deep:
    297             state = deepcopy(state, memo)
--> 298         if hasattr(y, '__setstate__'):
    299             y.__setstate__(state)
    300         else:

ValueError: wrapper has not been initialized

To fix this, I implemented the __copy__() and __deepcopy__() methods in a subclass of ObjectProxy:

from wrapt import ObjectProxy
import copy

class CopyableObjectProxy(ObjectProxy):

    def __copy__(self):
        copied_wrapped = copy.copy(self.__wrapped__)
        return self.__class__(copied_wrapped)

    def __deepcopy__(self):
        copied_wrapped = copy.deepcopy(self.__wrapped__)
        return self.__class__(copied_wrapped)

x = 1
xp = ObjectProxy(x)
xcp = CopyableObjectProxy(x)

print(copy.copy(x))
try:
    print(copy.copy(xp))
except ValueError:
    print("Copy of xp failed")
print(copy.copy(xcp))

However, this presumably will not work for more complex proxy classes that have their own state that also needs copying. Is there a way to implement this generally for any proxy object, or does every subclass of ObjectProxy need to provide a custom __copy__() method if it wants to be copyable?

[GrahamDumpleton]

Example of what custom object proxy needs to do if know it needs to be copied is:

class CustomObjectProxy(wrapt.ObjectProxy):

    def __copy__(self):
        return CustomObjectProxy(copy.copy(self.__wrapped__))

    def __deepcopy__(self, memo):
        return CustomObjectProxy(copy.deepcopy(self.__wrapped__, memo))

The reason can’t really provide these as defaults is because can’t be certain that constructor for class only takes the object to be wrapped. It may have to take extra arguments. It is arguably better to have it fail with an exception immediately, rather than it subsequently fail with an even more obscure error message.

[GrahamDumpleton]

Added default copy methods which raise not implemented error in https://github.com/GrahamDumpleton/wrapt/commit/67c09effcb2f70ac9af7dba60451ab37dd0cd8fb