Good solutions for passing around large numbers of arguments in a layered architecture?

[Nathan Rice]

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?