Question

Ok, so I’m having a bit of a problem here. I need to be able to create a sort of import/export functionality for some sqlalchemy. Now these are not objects I’m defining, so to get the columns I’m doing:

for attr, value in res.__class__.__dict__.iteritems():
     if isinstance(value, InstrumentedAttribute):
          data = eval("res." + str(attr))
          param_dict[attr] = data

Now this correctly gets me the attributes of that object. However, I can;t be certain that the parameters of the init are the same, since I’m not the one handling this objects. So there could be a situation like:

class SomeClass(model.Base):
    my_column = Column(String)
    ....some other stuff...

    def __init__(self, mycolumn, ...):
           self.my_column = mycolumn

So in this case I don’t have any correspondance between the name of the field and the name of the parameter as recieved by init. I’m currently contraining the ones who define these classes to have all the init parametes with a default value so I could just:

obj = SomeClass()
exec "obj." + attr + " = " + param[attr]

However I would like to get away even from this constrain. Is there any way I can achieve this?

Answer 1

Serializing can’t really be generalized for all possible sqlalchemy mapped classes, classes might have properties that aren’t stored in the database, or that must be inferred across multiple levels of indirection through relationship properties. In short, only you know how to serialize a particular class for a particular use.

---

Lets pretend that you only need or care about the column values for the specific instance of the specific class under consideration (in res). Here’s a crude function that will return a dict containing only those values.

from sqlalchemy.orm.attributes import manager_of_class
from sqlalchemy.orm.properties import ColumnProperty

def get_state_dict(instance):
    cls = type(instance)
    mgr = manager_of_class(cls)
    return dict((key, getattr(instance, key))
                for key, attr in mgr.iteritems()
                if isinstance(attr.property, ColumnProperty))

and to recreate an instance from the dict*

def create_from_state_dict(cls, state_dict):
    mgr = manager_of_class(cls)
    instance = mgr.new_instance()
    for key, value in state_dict.iteritems():
        setattr(instance, key, value)
    return instance

If you need something more complex, probably handling the relationships not shown as columns (as in many-to-many relationships), you can probably add that case by looking for sqlalchemy.orm.properties.RelationshipProperty, and then iterating over the collection.

*_{Serializing the intermediate dict and class is left as an exercise.}