From: Jean-Michel Pichavant on
Nathan Rice wrote:
> I've been running into a problem lately where I have an architecture like so:
> Main class -> facade/configuration class -> low level logic class.
> The main class is what the user interacts with.
> The facade/config class is responsible for loading and managing the
> lower level classes and providing a consistent interface to the main
> class. It can be hot swapped in/out to drastically change the
> functionality of the main class.
> The low level logic classes are responsible for dealing with domain primitives.
> The issue I'm having is that I want advanced users to be able to pass
> extra configuration information to the facade and low level classes if
> need be, without the signature drastically changing with different
> facade classes. Currently, I explicitly state parameters as much as
> possible at each level. To deal with low level logic classes that
> have a large number of possible options I allow the caller to pass a
> dictionary of options for that class. This leaves me with signatures
> that are upwards of 15 arguments long in some cases, the majority of
> them repeated in classes called from the main class.
> I've tried using args/kwargs, however I found it difficult to avoid
> having arguments in my signature re-ordered, and it is also a source
> of bugs.
> Has anyone come up with a good solution for dealing with arguments in
> situations like this where you'd like to encapsulate lower level stuff
> for neophyte users but make it easily available to advanced users?
Use objects.

def foo(a,b,c,d, moreOptions=None):

class MoreOptions:
"""Write the documentation about all the available options"""
def __init__(self):