How can I decide which declarative model to instantiate, based on row information

I'm building a webapp that has optional Facebook Login. The users created through the Facebook API are handled differently at several points in my application. I want to encapsulate these differences in a subclass of Person that overrides methods.

class Person(Model):
    def get_profile_picture(self):
        return profile_pictures.url(self.picture)

class FacebookPerson(Person):
    def get_profile_picture(self):
        return 'http:/.../%s.jpg' % self.graph_id

I would like to avoid the nasty if self.graph_id and just query the Person model and get th开发者_C百科e right object for each user.

I've thought of hacking the metaclass to add the FacebookPerson as a base. Obviously I would like to avoid such voodoo.

I'm using Flask and Flask-SQLAlchemy.

The general idea would be to store the model's class name as metadata in each row, and when you instantiate the object, do something like:

def query(self):
    # stuff
    return model_class(data)

To do this in SQLAlchemy, you might look at making Person the base class to something like BasicPerson and FacebookPerson, and in Person.init(), use the metadata to initialize to the proper subclass.

For example, the idea would be than when this query returns, user will have been initialized to the proper subclass:

user = session.query(Person).filter_by(name='james').first()

You will probably need to modify this concept a bit for SQLAlchemy (I haven't used it in a while), but that's the general idea.

Or, you could do something like store the metadata in a cookie with the user_id, and then when they log in again, use the metadata to pass the proper class to the user query:

user = session.query(FacebookPerson).filter_by(name='james').first()

If you want this to be generic so that the metatdata is meaningful to non-Python clients, instead of storing the model's class name, store the model's "object_type" and have something in each client library that maps object_types to classes.