Don't use functools.update_wrapper then.

There is a piece of code updating PlusOne(identity).fun:

def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    for attr in assigned:
        try:
            value = getattr(wrapped, attr)
        except AttributeError:
            pass
        else:
            setattr(wrapper, attr, value)
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
    # Issue #17482: set __wrapped__ last so we don't inadvertently copy it
    # from the wrapped function when updating __dict__
    wrapper.__wrapped__ = wrapped
    # Return the wrapper so this can be used as a decorator via partial()
    return wrapper

    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))

The culprit here is the __dict__ update; when the wrapped is a PlusOne instance, this results in copying the wrapped fun attribute to the wrapper.

This does mean that the default behavior of functools.update_wrapper can be a bit of a foot-gun when used with callable instances rather than normal functions, since all attributes of the wrapped callable will be copied to the wrapper callable by default.

This is easy to work around; just use functools.update_wrapper(self, self.fun, updated=[]) to avoid the default updating of __dict__.

This behavior of functools.update_wrapper is clearly documented and longstanding, therefore I don't think it's a bug, nor do I think it will be changed.

I do think the update_wrapper documentation could be clearer about this risk, however, especially since it specifically notes that update_wrapper is usable with callable instances, not just functions. I would support a documentation update briefly mentioning this risk, in the paragraph that begins "update_wrapper() may be used with callables other than functions." Some wording like "The default behavior of updating all __dict__ contents may copy more attributes than desired when used with callable instances; passing updated=[] will avoid this."

I updated the wording of the OP to clarify the actual issue.