Accessing ObjectProxy __dict__

[dg-pb]

After p = ObjectProxy(obj) has been constructed, is there any way to retrieve p.__dict__ of the ProxyObject and not the __wrapped__?

I have found that I can set attributes to p and not __wrapped__ if name.startswith('_self_'), but it would be more convenient just to have access to __dict__ itself.

[GrahamDumpleton]

What is it that you are trying to do that requires this? Knowing the underlying reason, rather than what you think may be the solution will help me guide you better as to what is the best approach to solving the actual problem.

[dg-pb]

I have a descriptor:

class Descriptor(ObjectProxy):
    def __init__(self, attr)
        self.attr = attr

    def __call__(self, wrapped):
        super().__init__(wrapped)

    def __get__(self, inst, owner):
        return self.__wrapped__(self.attr)

So I want to keep inheriting from ObjectProxy, but at the same time I want to store some attributes in descriptor class. If I do it the way I did in my example:

1. It raises an error because I am assigning it before ObjectProxy was initialised.
2. Even if it was (I could initialise it with empty namespace and then re-initialise it), it would assign attribute to wrapped rather than descriptor class.

As I said, I could assign to attribute name _self_attr and it would work, but I have more than one and I would prefer to have an access to actual __dict__ of ObjectProxy than need to use _self_ starting attribute names.

Currently I made one myself via:

class ObjectProxy(wrapt.ObjectProxy):
    def __init__(self, *args, **kwds):
        super().__init__(*args, **kwds)
        if not hasattr(self, '_self_dict__'):
            setattr(self, '_self_dict__', dict())

    @property
    def __dictp__(self):
        return getattr(self, '_self_dict__')

However, I would like to avoid extra function call if there was a way to do it cleaner.

[mentalisttraceur]

I think object.__getattribute__(p, "foo") and object.__setattr__(p, "foo", new_value) would work to get and set attributes in p's __dict__. Haven't tested but pretty sure.

And so object.__getattribute__(p, "__dict__") might work to get the proxy's attribute dict. Only slightly less confident this would also work.

But I agree with Graham's gentle resistance to this - maybe you shouldn't mess with the wrapper's dict. In fact, I would assume that the object proxy's dict is considered a private space for wrapt implementation details, where your usage might randomly break things or be randomly broken.

[dg-pb]

These don't work for C implementation, however I am pretty sure they do in pure python.

Making it work in C, would make these more similar :)

[GrahamDumpleton]

Look at #255 (comment)

Didn't occur to me before to add a dummy class attribute so that assignment to instance in constructor would then use the instance rather than wrapped object.

This may be a solution for what ultimately you are trying to do if the intent was attributes exclusively on the wrapper, without using _self_ prefix.