Handing a number of methods to the same child class

[Dave Merrill]

Python newb here. Say a class contains some rich attributes, each defined as
a class. If an instance of the parent class recieves a call to a method
belonging to one of those attributes, it should be dispatched to the
corresponding child class.

Somewhat silly example:

class Address:
def __init__():
self.displayed_ name = ''
self.adr = ''
self.city = ''
self.state = ''
def set_name(name):
self.displayed_ name = name
def set_adr(adr):
self.adr = adr
def set_city(city):
self.city = city
def set_state(state ):
self.state = state

class Phone:
def __init__():
self.displayed_ name = ''
self.number = ''
def set_name(name):
self.displayed_ name = name
def set_number(numb er):
self.number = number

class Customer:
def __init__():
self.last_name = ''
self.first_name = ''
self.adr = Adr()
self.phone = Phone()
def set_adr_name(na me):
self.adr.set_na me(name)
def set_adr_adr(adr ):
self.adr.set_ad r(adr)
def set_adr_city(ci ty):
self.adr.set_ci ty(city)
def set_adr_state(s tate):
self.adr.set_st ate(state)
def set_phone_name( name):
self.phone.set_ name(name)
def set_phone_numbe r(number):
self.phone.set_ number(number)

IOW, all the adr methods go to the corresponding method in self.adr, all the
phone methods go to self.phone, theorectically etc for other rich
attributes.

What I'd really like is to say, "the following list of methods pass all
their arguments through to a method of the same name in self.adr, and the
following methods do the same but to self.phone." Is there some sane way to
express that in python?

Callers should stay ignorant about the internal structure of customer
objects; they should be talking only to the customer object itself, not its
components. Customer objects should stay ignorant of the internal structure
of addresses and phones; they should let those objects handle their own
implementation of the methods that apply to them.

What customer objects need to do is call the appropriate internal object for
each incoming method. How would you implement this? It's unfortunate to have
to create individual passthrough methods for everything, like the above,
among other reasons because it makes customer objects have to know about
each new method implemented by the objects they contain.

Am I making sense? Thanks,

Dave Merrill

[Steven Bethard]

Dave Merrill wrote:

Somewhat silly example:
I know you've hedged this by calling it a "silly" example, but I would
like to point out that your set_X methods are unnecessary -- since
Python allows you to overload attribute access, getters and setters are
generally unnecessary.
class Address:
def __init__():
self.displayed_ name = ''
self.adr = ''
self.city = ''
self.state = ''
def set_name(name):
self.displayed_ name = name
def set_adr(adr):
self.adr = adr
def set_city(city):
self.city = city
def set_state(state ):
self.state = state

class Phone:
def __init__():
self.displayed_ name = ''
self.number = ''
def set_name(name):
self.displayed_ name = name
def set_number(numb er):
self.number = number

class Customer:
def __init__():
self.last_name = ''
self.first_name = ''
self.adr = Adr()
self.phone = Phone()
def set_adr_name(na me):
self.adr.set_na me(name)
def set_adr_adr(adr ):
self.adr.set_ad r(adr)
def set_adr_city(ci ty):
self.adr.set_ci ty(city)
def set_adr_state(s tate):
self.adr.set_st ate(state)
def set_phone_name( name):
self.phone.set_ name(name)
def set_phone_numbe r(number):
self.phone.set_ number(number)

IOW, all the adr methods go to the corresponding method in self.adr, all the
phone methods go to self.phone, theorectically etc for other rich
attributes.

What I'd really like is to say, "the following list of methods pass all
their arguments through to a method of the same name in self.adr, and the
following methods do the same but to self.phone." Is there some sane way to
express that in python?

py> class Address(object) :
.... def __init__(self, city, state):
.... self.city = city
.... self.state = state
....
py> class Customer(object ):
.... def __init__(self, name, addr):
.... self.name = name
.... self.addr = addr
.... def __getattr__(sel f, attr):
.... if attr.startswith ('adr_'):
.... return getattr(self.ad dr, attr[4:])
.... raise AttributeError( attr)
....
py> c = Customer("Steve ", Address("Tucson ", "AZ"))
py> c.adr_city
'Tucson'
py> c.adr_state
'AZ'

I've used a slightly different example from yours, but hopefully you can
see how to apply it in your case. The __getattr__ method is called when
an attribute of an object cannot be found in the normal locations (e.g.
self.__dict__). For all attributes that begin with "adr_", I delegate
the attribute lookup to the self.addr object instead.

Steve