Esteemed colleagues!
Please consider...
#!/usr/bin/env python3.6
class Child(object):
def __init__(self, name:str, value = 0):
self.name = name;
self.value = value;
def __repr__(self):
return ' child "{}" has value {}\n'.format(self.name, self.value)
class Parent(object):
def __init__(self, name:str):
self.name = name
self.children = {}
def __repr__(self):
s = 'Parent "{}":\n'.format(self.name)
for k, v in self.children.items():
s += v.__repr__()
return s
def __getattr__(self, name:str):
if name == 'children':
return self.children;
elif name in self.children.keys():
return self.children[name].value
else:
return super().__getattr__(name)
def __setattr__(self, prop, val):
if prop == 'name':
super().__setattr__(prop, val)
else:
super().__setattr__('children[{}]'.format(prop), val)
p = Parent('Tango')
p.children['Alfa'] = Child('Alfa', 55)
p.children['Bravo'] = Child('Bravo', 66)
print(p)
print(p.children['Alfa']) # Returns '55' (normal)
print(p.Alfa) # Returns '55' (__getattr__)
print('-----')
p.Alfa = 99 # This is creating a new variable, need __setattr__ ...
print(p.Alfa) # Prints new variable. __setattr__ is not called!
print('-----')
print(p.children['Alfa']) # Still '55'
print(p) # Still '55'
The intent of the code is to allow those holding a Parent to access its children in TWO ways: p.children['Alfa'] or p.Alfa.
Using __getattr__() I can accomplish the read-side of this. (Comment out the def __setattr__() in the code above and you can see the read-side work as expected.) Output without setattr() is:
Parent "Tango":
child "Alfa" has value 55
child "Bravo" has value 66
child "Alfa" has value 55
55
-----
99
-----
child "Alfa" has value 55
Parent "Tango":
child "Alfa" has value 55
child "Bravo" has value 66
Of course now I need __setattr__() to accomplish the write-side of this. I want 99 to be assigned to Alfa. As of now, haven't figured out the incantation to avoid a variety of issues.
The code above with setattr() raises RecursionError:
Traceback (most recent call last):
File "./test.py", line 37, in <module>
p.children['Alfa'] = Child('Alfa', 55)
File "./test.py", line 23, in __getattr__
return self.children;
File "./test.py", line 23, in __getattr__
return self.children;
File "./test.py", line 23, in __getattr__
return self.children;
[Previous line repeated 328 more times]
File "./test.py", line 22, in __getattr__
if name == 'children':
RecursionError: maximum recursion depth exceeded in comparison
I expect the test code that follows to show that by writing to p.Alfa, that I am actually updating the value of self.children['Alfa']. After the assignment, 99 should appear when I print it, not the original 55.
Note that in the real world, there is a nearly infinite number of possible children, their names, and their contents.
Your help and insight is appreciated!
def __setattr__(self, attr, val):
if attr == 'name':
super().__setattr__(self, 'name', val)
return
self.children[attr] = val
Your code never initializes an attribute named children. It initializes one named children[children]. As a result, when you later try to assign to self.children['Alfa'], the first thing it tries to do is find an attribute named children. When it isn't found, it calls __getattr__, which says that when name == "children", it should return self.children, and the infinite loop begins.
__getattr__ is only called when an attribute is not found via the normal process. With __setattr__ defined correctly, __getattr__ should never be called for children, since you define it in __init__. The definition can be reduced to
def __getattr__(self, name:str):
if name in self.children.keys():
return self.children[name].value
else:
return super().__getattr__(name)