I have a project, with some modules each of which contains a class doing their respective thing. Then I have an API class for the user. The API class instantiate those classes, and should forward/redirect to those who are doing the actual processing. I have the following questions:
How do I do the forwarding without rewriting what seems to me redundant code? For example, say Foo
is the API class, Bar
is a module class, then now I am writing something like:
class Foo:
def __init__(self, bar: Bar):
self.bar = bar
def name(self):
return self.bar.name()
I explicitly wrote name
method in Foo
, which just returns name()
of Bar
. Isn't this redundant? Is there an "automatic" way to forward the call?
In the bar
class I'd write some docstrings. Is there a way to "port" these docstrings to the API class Foo
? Writing them again in Foo
would be redundant and difficult to maintain.
Try redirecting the __getattr__
magic method:
class Foo:
def __init__(self, bar: Bar):
self.bar = bar
def __getattr__(self, attr):
return getattr(self.bar, attr)
This would redirect all functions to the bar
variable.
For multiple classes:
class Foo:
def __init__(self, bar: Bar, foo: Foo, blah: Blah):
self.bar = bar
self.foo = foo
self.blah = blah
def __getattr__(self, attr):
if hasattr(self.bar, attr):
return getattr(self.bar, attr)
elif hasattr(self.foo, attr):
return getattr(self.foo, attr)
else:
return getattr(self.blah, attr)