Class introspection and dynamically determining function arguments

Mike C. Fletcher mcfletch at
Sat Jan 22 02:23:58 CET 2005

>On Thu, 20 Jan 2005 11:24:12 -0000, "Mark English" <Mark.English at> wrote:
>>I'd like to write a Tkinter app which, given a class, pops up a
>>window(s) with fields for each "attribute" of that class. The user could
>>enter values for the attributes and on closing the window would be
>>returned an instance of the class. The actual application I'm interested
>>in writing would either have simple type attributes (int, string, etc.),
>>or attributes using types already defined in a c-extension, although I'd
>>prefer not to restrict the functionality to these requirements.
Hmm, I missed the original post, but I'll jump in anyway:

    This sounds a heck of a lot like a property-editing system.  When
    creating a property-modeled system, the best approach is normally to
    use something that actually models the properties, rather than
    trying to guess at the metadata involved by poking around in an
    arbitrarily structured object.

    My BasicProperty system allows for this kind of interaction
    (property-sheets) using wxPython (rather than Tkinter) when using
    wxoo.  You declare classes as having a set of data-properties (which
    can have defaults or not, constraints or not, restricted data-types
    or not, friendly names or not, documentation or not).  Normally you
    create these classes as subclasses of a class that knows how to
    automatically assign __init__ parameters to properties, and knows
    how to tell (e.g.) wxoo about the properties of the class.

    Those same property classes also allow for editing properties of
    database rows in PyTable, but that isn't likely relevant to your
    case.  We've also used them internally to create a rather large
    web-based property-editing mechanism (applied to such databases),
    but again, not really relevant to the case at hand.

Anyway, if you aren't interested in BasicProperty for this task; another 
project on which I work, PyDispatcher provides fairly robust mechanism 
(called robustApply) for providing a set of possible arguments and using 
inspect to pick out which names match the parameters for a function in 
order to pass them in to the function/method/callable object.  That 
said, doing this for __init__'s with attribute values from an object's 
dictionary doesn't really seem like the proper way to approach the problem.

Good luck,

  Mike C. Fletcher
  Designer, VR Plumber, Coder

More information about the Python-list mailing list