Open dg-pb opened 10 months ago
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.
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:
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.
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.
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 :)
Look at https://github.com/GrahamDumpleton/wrapt/issues/255#issuecomment-1817722900
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.
After
p = ObjectProxy(obj)
has been constructed, is there any way to retrievep.__dict__
of theProxyObject
and not the__wrapped__
?I have found that I can set attributes to
p
and not__wrapped__
ifname.startswith('_self_')
, but it would be more convenient just to have access to__dict__
itself.