from django.db.models.loading import get_models as get_new_models, get_app as get_new_app

from django.contrib.migratory import manager, snapshot

        self.manager = manager.DatabaseManager(style=self.style, verbosity=options['verbosity'])

        try:

            if app_name not in self.manager:

                raise CommandError("Unable to find previous snapshot of app %r." % app_name)

        except:

            # No snapshots yet, so we kick out.

            return

        app = get_new_app(app_name)

        new_models = get_new_models(app)

        old_models = self.manager.get_models(app_name)

        changeset = Changeset(app)

                old_snap = snapshot.field_snap(old, old_model)

                new_snap = snapshot.field_snap(new, new_model)

        changeset.save(filename)  

        print changeset.report()

        if (changeset):

            print "\nPlease look over the changes. When you feel confident they are correct, issue a 'syncdb':\n> python manage.py syncdb"

            "database.drop_model(%r)" % model._meta.object_name

            "database.add_model(%r)" % model._meta.object_name

                model_changes

                self.model._meta.object_name, new._meta.object_name)

                self.model._meta.object_name, field.name)

                self.model._meta.object_name, field.name)

                    self.model._meta.object_name, old.name, new.name)

        for report, sub in self.changes:

            if not isinstance(sub, basestring):

                for report, _ in sub:

        for _, code in self.changes:

            if isinstance(code, basestring):

                gather.append(code)

                for _, sub in code:

                    gather.append(sub)

        return "def up(database):\n    %s\n" % '\n    '.join(gather) 

    def get_migrations_dir(self):

        """

        Gets or creates the migration directory on the filesystem.

        """

        path = os.path.join(os.path.dirname(self.app.__file__), 'migrations')

        if not os.path.isdir(path):

            os.mkdir(path)

        return path

    def get_manifest(self):

        """

        get_manifest() -> (path, src)

        Returns the manifest (__manifest__.py) path and source.

        """

        migrations_dir = self.get_migrations_dir()

        path = os.path.join(migrations_dir, '__manifest__.py')

        if not os.path.exists(path):

            src = '[\n]'

            o = open(path, 'w')

            o.write(src)

            o.close()

        else:

            o = open(path, 'r')

            src = o.read()

            o.close()

        return path, src

    def save(self, filename, comment = ''):

        """

        Saves the changeset to a new migration file, and appends to the 

        manifest (__manifest__.py).

        """

        path, src = self.get_manifest()

        manifests = eval(src)

        if (filename in manifests):

            raise CommandError("A migration with that name (%r) is already present in the manifest." % filename)

        lines = src.split('\n')

        spaces = '    '

        if len(lines) > 2:

            # Get the padding of the previous line.

            prev = lines[-2]

            spaces = prev[: len( prev ) - len( prev.lstrip() ) ]    

        line = spaces + repr(filename) + ','

        if (comment):

            count = len(line)

            if '\t' in spaces:

                for c in spaces:

                    if c == '\t': count += 3

            line += (50 - count) * ' ' + '# ' + comment

        lines.insert(-1, line)

        print "Adding %r to manifest..." % filename

        o = open(path, 'w')

        o.write( "\n".join(lines) )

        o.close()

        path = os.path.join(os.path.dirname(path), filename)

        if os.path.exists(path):

            print "Migration already exists: %s" % path

            return

        print "Writing migration to: %s" % path

        o = open(path, 'w')

        if path.endswith('.py'):

            o.write("\"\"\"\nDjango Migration %s\n%s\n\"\"\"\n\n" % \

                (filename, comment))

            o.write(self.up())

        o.close()

    def parse_sig(self, sig):

        """Turns 'app.Model' to ('app', 'model')."""

        if '.' not in sig:

            if self.app_name:

                return self.app_name, sig

            else:

                raise KeyError("Must specify the app_name, like: app.model, unless you set it on the DatabaseManager constructor.")

            return sig.split('.')

    def __getitem__(self, sig):

        """Return the model matching the sig from the latest snapshot."""

        return self.get_model(*self.parse_sig(sig))

    def get_model(self, app_name, model_name):

        """Return the request model from the latest snapshot."""

        if app_name not in self._apps:

            self.build_app(app_name)

            self.build_rel_fields()

        try:

            return self._apps[app_name][model_name]

        except:

            models.get_model(app_name, model_name)

    def get_models(self, app_name=None):

        """Return an iterator of models in the latest snapshot."""

        if app_name not in self._apps:

            self.build_app(app_name)

            self.build_rel_fields()

        if (app_name):

            return iter( self._apps[app_name].values() )

        else:

            for app, models in self._apps.items():

                return iter( models.values() )

    def __contains__(self, app_name):

        """Does the latest snapshot include this app?"""

        return Snapshot.objects.filter(app=app_name).count() > 0

    def build_app(self, app_name):

        """

        Build a dict of models for the given application name from the latest 

        snapshot

        """

        if (app_name in self._apps):

            return

        try:

            snap = Snapshot.objects.get(app=app_name)

        except Snapshot.DoesNotExist:

            try:

                models.get_app(app)

                self._dicts[app_name] = {} # New app, allow it.

                return

            except ImproperlyConfigured:

                raise RuntimeError("Cannot find snapshot of an app named %r." % app_name)

        data = simplejson.loads(snap.json)

        self._apps[app_name] = {}

        for dct in data:

            self.build_model(app_name, dct)

    def build_model(self, app_name, dct):

        """

        Builds a model with the given app_name and snapshot-dict.

        """

        attrs = {}

        app_name = app_name.encode()

        attrs.update( self.build_fields(app_name, dct['name'], dct['meta'], dct['fields']) )

        attrs['Meta'] = type('Meta', (), dct['meta'])

        attrs['Meta'].app_label = 'migration-' + app_name

        attrs['__module__'] = dct['module'].encode()

        model = type(str(dct['name'].encode()), (models.Model,), attrs)

        self._apps[app_name][model._meta.object_name] = model

    def build_fields(self, app_name, model_name, model_meta, dicts):

        """

        Builds a field for each dict given.

        This will also populate self._rel_fields with any related fields, and

        self._required with required apps.  Only after all the required apps 

        and models are built will the relative fields be added with 

        self.build_rel_fields() below.

        """

        gather = {}

        for dct in dicts:

            name = dct['name'].encode()

            cls = getattr(models, dct['__class__'])

            attrs = {}

            for k, v in dct.items():

                if not k.startswith('_'): attrs[str(k)] = v

            if ('__rel__' in dct):

                to_app_name, to_model_name = dct['__rel__']

                if (to_app_name not in self._apps):

                    self._required.add( to_app_name )

                if model_meta.get('order_with_respect_to') == name:

                    del model_meta['order_with_respect_to']

                    attrs['__order_with_respect_to'] = True

                self._rel_fields.append( (app_name,

                                          model_name, 

                                          cls, 

                                          name, 

                                          to_app_name, 

                                          to_model_name, 

                                          attrs) )

            else:

                gather[name] = cls(**attrs)

        return gather

    def build_rel_fields(self):

        """

        Only once all the required apps and models are built, do we

        actually add the relative fields.

        """

        while self._required:

            self.build_app( self._required.pop() )

        for (app_name,

             model_name,

             cls,

             name,

             to_app_name,

             to_model_name,

             attrs) in self._rel_fields:

            order = attrs.pop('__order_with_respect_to', False)

            model = self.get_model(app_name, model_name)

            to_model = self.get_model(to_app_name, to_model_name)

            field = cls(to_model, **attrs)

            model.add_to_class(name, field)

            if order:

                model._meta.order_with_respect_to = field.name

                model._meta._prepare(model)

        self._rel_fields = []

        The field should be defined in the current models.py

        TODO: This won't work, because we might be in a long-ago migration 

        refering to models.py that doesn't have the field, or model for that 

        matter. Big problem.

        model = self.get_model(app_name, model_name)

        real_model = models.get_model(app_name, model_name)

        field = real_model._meta.get_field(name)

        model = self.get_model(app_name, model_name)

        real_model = models.get_model(app_name, model_name)

        real_opts = model._meta

        field = opts.get_field(new_field_name)

        model = models.get_model(*self.parse_sig(model_sig))

    def rename_model(self, model_sig, new_sig):

        old_model = self[model_sig]

        app_name, model_name = self.parse_sig(new_sig)

        new_model = models.get_model(app_name, model_name)

        self._apps[app_name][model_name] = new_model

        # TODO: Check through self.created_models before doing this.

        sql = [

            style.SQL_KEYWORD('DROP TABLE'),

            style.SQL_TABLE(qn(new_model._meta.db_table))

        ]

        self.execute('Dropping eroneously created table for %s.' % new_sig, sql)

            style.SQL_TABLE(qn(old_model._meta.db_table)),

            style.SQL_TABLE(qn(new_model._meta.db_table))

        model = self[model_sig]

This is not to be confused with the ./manage.py command which creates 

migration files rather than actually performing them.

    if (verbosity > 1 and mode != 'sql'): print "%s found." % len(migrations.keys())

    if migrations:

        database_manager = DatabaseManager(app_name, 

                                           verbosity=verbosity,     

                                           created_models=created_models or [],

                                           style=style,

                                           mode=mode)

        for name, path in migrations.items():

            if (verbosity >= 1 and mode != 'sql'): print "Executing migration %r..." % name

            if run_migration(path, database_manager, verbosity):

                Migration.objects.get_or_create(name=name)

def run_migration(path, database_manager, verbosity, sql_only=False):

    if not os.path.exists(path):

        raise RuntimeError(

            "Unable to find migration at the given path: %r" % path)

    o = open(path)

    src = o.read()

    o.close()

    namespace = {}

    exec src in namespace

    up = namespace.get('up', None)

    if (up):

        try:

            up(database_manager)

            return True

        except Exception, e:

            import traceback, sys

            lines = ["\nError in migration:\n"]

            lines.extend(traceback.format_tb(sys.exc_traceback)[1:])

            lines.append("%s: %s" % (e.__class__.__name__, str(e)))

            lines.append("\n\nLocals:\n")

            tb = sys.exc_info()[2]

            while tb.tb_next:

                tb = tb.tb_next

            frame = tb.tb_frame

            for key, value in frame.f_locals.items():

                try:

                    value = "%r" % value

                except:

                    value = '<not representable>'

                lines.append("\t%s: %s\n" % (key,value))

            raise RuntimeError("".join(lines))

    else:

        print "Nevermind, no up() defined."

    gather = {}