Python Type Consistency
-----------------------

What I mean by type consistency is the ability to create instances
of the most derived types defined in different metamodels. When
Python instantiates elements, all of them are wrapped in a single
class, "Element".  This is somewhat unacceptable for a couple
of reasons, mainly down-the-road specialization. What I'd like
to in Python is this:

import Model

cls = Model.Class()
print cls
<Model.Class instance @ xxx>

This is actually pretty tough to do because we instantiate elements
in lots of different places - like list Conversions. Somehow we need
to figure out what specific type of element to instantiate. I suspect
a decent answer would be to register a basic string like "Model.Class"
with a pointer to a factory that creates the right Python object.

However, what we might also like to do is start caching these objects.
This prevents the enormous overhead of continually allocating temporary
wrappers for these objects... Unfortunately, I'm not entirely sure what
their lifetime actually looks like. I feel marginally sure that Python
is discarding the PyObject wrappers that boost creates, but the internal
structures, i think, remain in memory (maybe).

After some experimenting, I've discovered that all I have to do is
have the most-derived factories return the wrapped python object.
Now comes the tricky part... where do I put singleton that manages
factories and stuff. Ideally, it would be in the OMF python module.
However it could be in the OMF core as well... Just a little bit
of help.