DeadWisdom / Migratory / changeset / cf4e00170a7e

Up to file-list README:

@@ -13,3 +13,7 @@ And then run the tests:
     cd test_project
     ./test
 == App Layout ==
 The main entry points to the app are events hooked in migratory/models.py and
 the ./manage.py command 'migrate' in migratory/management/commands/migrate.py

Up to file-list migratory/management/commands/migrate.py:

 """
 Automation of the creation of migration scripts.
 """
 import os, os.path
 from datetime import date
@@ -8,33 +12,138 @@ from django.core.management.color import
 from django.contrib.migratory import manager, snapshot
 from django.contrib.migratory.matchmaker import matchmaker, compare_strings
 class Command(BaseCommand):
     help = "Creates a migration file based on the delta of last snapshot to the current models, adds it to the migration manifest."
     args = '<app-name migration-name>'
     def handle(self, *args, **options):
         try:
             app_name, mig_name = args
         except:
             raise CommandError("Specify the name of an app, and a slug-formatted name for the migration.")
         self.manager = manager.DatabaseManager()
         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)
         # The order of old_models then new_models is important here, as
         # compareModels weights so that all the models in old are also in new.
         # If new has a bunch of new ones, it still makes a perfect match.
         matches, drop, add = matchmaker(old_models, new_models, compareModels, .4)
         changeset = Changeset(app)
         for model in drop:
             changeset.drop_model(model)
         for model in add:
             changeset.add_model(model)
         for old_model, new_model in matches:
             old_opts, new_opts = old_model._meta, new_model._meta
             fields, drop, add = matchmaker(
                         old_opts.local_fields + old_opts.local_many_to_many,
                         new_opts.local_fields + new_opts.local_many_to_many,
                         compareFields,
                         .5)
             changeset.change_model(old_model)
             if (old_model._meta.object_name != new_model._meta.object_name):
                 changeset.rename_model(new_model)
             for field in drop:
                 changeset.drop_field(field)
             for field in add:
                 changeset.add_field(field)
             for old, new in fields:
                 old_snap = snapshot.field_snap(old, old_model)
                 new_snap = snapshot.field_snap(new, new_model)
                 # Strip the 'migration-' prefix for the app on the
                 # related-field.
                 if old_snap.get('__rel__'):
                     old_snap['__rel__'] = (
                         old_snap['__rel__'][0].replace('migration-', ''),
                         old_snap['__rel__'][1]
+                    )
                 if (old.name != new.name):
                     changeset.change_field(old, new)
                 elif (old_snap != new_snap):
                     changeset.change_field(new)
             changeset.end_model()
         today = date.today()
         if mig_name.endswith('.py') or mig_name.endswith('.sql'):
             filename = mig_name
         else:
             filename = "%d-%d-%d-%s.py" % (
                 today.year, today.month, today.day, mig_name
+            )
         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 ./manage.py syncdb"
 ### Helper Functions / Classes ###
 def compareModels(a, b):
     name_coef = compare_strings(a._meta.object_name, b._meta.object_name)
     name_coef *= .5
     """
     Comparison func that returns a coefficient of similarity (0.0 to 1.0)
     for the given models.
     """
     name = compare_strings(a._meta.object_name, b._meta.object_name)
     fields_a = set(f.name for f in a._meta.local_fields + a._meta.local_many_to_many)
     fields_b = set(f.name for f in b._meta.local_fields + b._meta.local_many_to_many)
     fields_a = set(
         f.name for f in a._meta.local_fields + a._meta.local_many_to_many)
     fields_b = set(
         f.name for f in b._meta.local_fields + b._meta.local_many_to_many)
     similarity = len(fields_a.intersection(fields_b)) / float( len(fields_a) ) * .5
     coef = name_coef + similarity
-    return coef
+    fields = len( fields_a.intersection(fields_b) ) / float( len(fields_a) )
     return ( name * .5 ) + ( fields * .5 )
 def compareFields(a, b):
     coef = compare_strings(a.name, b.name)
     coef *= .5
     """
     Compare two given fields.
     """
     name = compare_strings(a.name, b.name) * .5
     if a.__class__ == b.__class__:
-        coef += .5
+        cls = .5
     else:
         coef += compare_strings(a.__class__.__name__, b.__class__.__name__) * .5
     return coef
         cls = compare_strings(a.__class__.__name__, b.__class__.__name__)
     return ( name * .5 ) + ( cls * .5 )
 class Changeset(object):
     """
     Records changes to a model, and then is able to produce a script for those
     changes and/or print out verbiage for those changes.
     """
     def __init__(self, app):
         self.changes = []
         self.app = app
     def __bool__(self):
         """Are there any changes?"""
         return bool(self.changes)
     def drop_model(self, model):
@@ -50,10 +159,17 @@ class Changeset(object):
         ))
     def change_model(self, model):
         """
         Marks the beginning of changes to the model, end those changes with
         end_model()
         """
         self.model = model
         self._changes, self.changes = self.changes, []
     def end_model(self):
         """
         Marks the end of model changes.
         """
         model_changes = self.changes
         self.changes = self._changes
@@ -66,34 +182,42 @@ class Changeset(object):
     def rename_model(self, new):
         self.changes.append((
              "Rename to %r." % new._meta.object_name,
-             "database.rename_model(%r, %r)" % (self.model._meta.object_name, new._meta.object_name)
+             "database.rename_model(%r, %r)" % (
                 self.model._meta.object_name, new._meta.object_name)
         ))
     def drop_field(self, field):
         self.changes.append((
             "Drop the field %r." % field.name,
-            "database.drop_field(%r, %r)" % (self.model._meta.object_name, field.name)
+            "database.drop_field(%r, %r)" % (
                 self.model._meta.object_name, field.name)
         ))
     def add_field(self, field):
         self.changes.append((
             "Add the new field %r." % field.name,
-            "database.add_field(%r, %r)" % (self.model._meta.object_name, field.name)
+            "database.add_field(%r, %r)" % (
                 self.model._meta.object_name, field.name)
         ))
     def change_field(self, old, new=None):
         if (new):
             self.changes.append((
                 "Change to %r, renaming it %r." % (old.name, new.name),
-                "database.change_field(%r, %r, %r)" % (self.model._meta.object_name, old.name, new.name)
+                "database.change_field(%r, %r, %r)" % (
                     self.model._meta.object_name, old.name, new.name)
             ))
         else:
             self.changes.append((
                 "Change the field %r." % old.name,
-                "database.change_field(%r, %r)" % (self.model._meta.object_name, old.name)
+                "database.change_field(%r, %r)" % (
                     self.model._meta.object_name, old.name)
             ))
     def report(self):
         """
         Returns a natural language report of the changes as a big string.
         """
         gather = []
         for report, sub in self.changes:
@@ -108,6 +232,10 @@ class Changeset(object):
         return '\n'.join(gather)
     def up(self):
         """
         Produces the python source-code for the up() function that will be
         used in the migration script.
         """
         gather = []
         for _, code in self.changes:
@@ -123,12 +251,20 @@ class Changeset(object):
         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')
@@ -145,6 +281,10 @@ class Changeset(object):
         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):
@@ -154,8 +294,9 @@ class Changeset(object):
         spaces = '    '
         if len(lines) > 2:
             # Get the padding of the previous line.
             prev = lines[-2]
-            spaces = prev[: len( prev ) - len( prev.lstrip() ) ]    # Get the padding of the previous line.
+            spaces = prev[: len( prev ) - len( prev.lstrip() ) ]
         line = spaces + repr(filename) + ','
@@ -181,97 +322,7 @@ class Changeset(object):
         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("\"\"\"\nDjango Migration %s\n%s\n\"\"\"\n\n" % \
                 (filename, comment))
             o.write(self.up())
         o.close()
 class Command(BaseCommand):
     """
     A management command which takes one or more arbitrary arguments
     (labels) on the command line, and does something with each of
     them.
     Rather than implementing ``handle()``, subclasses must implement
     ``handle_label()``, which will be called once for each label.
     If the arguments should be names of installed applications, use
     ``AppCommand`` instead.
     """
     help = "Creates a migration file based on the delta of last snapshot to the current models, adds it to the migration manifest."
     args = '<app-name migration-name>'
     def handle(self, *args, **options):
         try:
             app_name, mig_name = args
         except:
             raise CommandError("Specify the name of an app, and a slug-formatted name for the migration.")
         self.manager = manager.DatabaseManager()
         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)
         # The order of old_models then new_models is important here, as compareModels
         # weights so that all the models in old are also in new.  If new has a bunch
         # of new ones, it still makes a perfect match.
         matches, drop, add = matchmaker(old_models, new_models, compareModels, .4)
         changeset = Changeset(app)
         for model in drop:
             changeset.drop_model(model)
         for model in add:
             changeset.add_model(model)
         for old_model, new_model in matches:
             fields, drop, add = matchmaker(old_model._meta.local_fields + old_model._meta.local_many_to_many,
                                            new_model._meta.local_fields + new_model._meta.local_many_to_many,
                                            compareFields,
                                            .5)
             changeset.change_model(old_model)
             if (old_model._meta.object_name != new_model._meta.object_name):
                 changeset.rename_model(new_model)
             for field in drop:
                 changeset.drop_field(field)
             for field in add:
                 changeset.add_field(field)
             for old, new in fields:
                 old_snap, new_snap = snapshot.field_snap(old, old_model), snapshot.field_snap(new, new_model)
                 if old_snap.get('__rel__'):
                     old_snap['__rel__'] = (old_snap['__rel__'][0].replace('migration-', ''), old_snap['__rel__'][1])
                 if (old.name != new.name):
                     changeset.change_field(old, new)
                 elif (old_snap != new_snap):
                     changeset.change_field(new)
             changeset.end_model()
         today = date.today()
         if mig_name.endswith('.py') or mig_name.endswith('.sql'):
             filename = mig_name
         else:
             filename = "%d-%d-%d-%s.py" % (today.year, today.month, today.day, mig_name)
         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 ./manage.py syncdb"

Up to file-list migratory/manager/base.py:

 """
 DatabaseManagerBase acts as the base for all database managers.
 __init__.py in this same folder imports the correct manager for backend
 specified in settings.DATABASE_ENGINE.  Those manager classes extend
 DatabaseManagerBase.
 """
 from django.core.management.color import no_style
 from django.utils import simplejson
 from django.db import models
 from django.db import connection
 from django.core.exceptions import ImproperlyConfigured
 qn = connection.ops.quote_name
 from django.contrib.migratory.models import Migration, Snapshot
 # Are we allowed to do this as a module level?  I am for now.
 qn = connection.ops.quote_name
 class DatabaseManagerBase(object):
-    def __init__(self, app_name=None, verbosity=0, test=False, style=None, created_models=[]):
+    """
     The database manager handles both the building of old snapshots into
     usable models, as well as the methods used to adjust the database
     representation.
     The database manager allows access of models through a __getitem__ method,
     so you can do:
         database = DatabaseManager()
         print database['app.Model'].objects.all()
     """
     def __init__(self, app_name=None,
                        verbosity=0,
                        test=False,
                        style=None,
                        created_models=[]):
         """
         app_name:
             The default application name, allows you to say database['Model],
             instead of database['app.Model']
         verbosity:
             The ./manage.py verbosity.
         test:
             Set to true, and we won't actually execute the sql.
         style:
             The ./manage.py style.
         created_models:
             In the case of a syncdb, these are the models that were just
             created.
         """
         self.app_name = app_name    # Default app
         self.verbosity = verbosity
         self.test = test
@@ -20,6 +64,7 @@ class DatabaseManagerBase(object):
         self._rel_fields = []
     def parse_sig(self, sig):
         """Turns 'app.Model' to ('app', 'model')."""
         if '.' not in sig:
             if self.app_name:
                 return self.app_name, sig
@@ -29,9 +74,11 @@ class DatabaseManagerBase(object):
             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()
@@ -41,6 +88,7 @@ class DatabaseManagerBase(object):
             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()
@@ -51,9 +99,14 @@ class DatabaseManagerBase(object):
                 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:
@@ -71,10 +124,13 @@ class DatabaseManagerBase(object):
             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['fields'], dct['meta'] ) )
+        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()
@@ -82,7 +138,15 @@ class DatabaseManagerBase(object):
         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, dicts, model_meta):
+    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:
@@ -99,79 +163,129 @@ class DatabaseManagerBase(object):
                 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) )
+                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_with_respect_to = attrs.pop('__order_with_respect_to', False)
         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_with_respect_to:
+            if order:
                 model._meta.order_with_respect_to = field.name
                 model._meta._prepare(model)
         self._rel_fields = []
     def _field_sql(self, model, field):
         """
         Generate the sql needed to create a field.
         """
         style = no_style()
         opts = model._meta
         qn = connection.ops.quote_name
         col_type = field.db_type()
         tablespace = field.db_tablespace or opts.db_tablespace
         null = 'NULL'
         if (not field.null):
             null = 'NOT NULL'
         sql = [
             style.SQL_FIELD( qn(field.column) ),
             style.SQL_COLTYPE( col_type ),
             style.SQL_KEYWORD( null ),
+        ]
         if field.primary_key:
             sql += [
                 style.SQL_KEYWORD('PRIMARY KEY')
+            ]
         elif field.unique:
             sql += [
                 style.SQL_KEYWORD('UNIQUE')
+            ]
         # Make the definition (e.g. 'foo VARCHAR(30)') for this field.
         field_output = [style.SQL_FIELD(qn(field.column)), style.SQL_COLTYPE(col_type)]
         field_output.append(style.SQL_KEYWORD('%sNULL' % (not field.null and 'NOT ' or '')))
         if field.primary_key:
             field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
         elif field.unique:
             field_output.append(style.SQL_KEYWORD('UNIQUE'))
         if tablespace and field.unique:
             # We must specify the index tablespace inline, because we
             # won't be generating a CREATE INDEX statement for this field.
-            field_output.append(connection.ops.tablespace_sql(tablespace, inline=True))
+            sql += [
                 connection.ops.tablespace_sql(tablespace, inline=True)
+            ]
         if field.rel:
-            part = [
+            column = field.rel.to._meta.get_field(field.rel.field_name).column
             sql += [
                 style.SQL_KEYWORD('REFERENCES'),
                 style.SQL_TABLE(qn(field.rel.to._meta.db_table)),
                 '(%s)' % style.SQL_FIELD(qn(field.rel.to._meta.get_field(field.rel.field_name).column)),
                 style.SQL_TABLE( qn(field.rel.to._meta.db_table) ),
                 '(%s)' % style.SQL_FIELD( qn(column) ),
+            ]
             deferrable = connection.ops.deferrable_sql()
             if (deferrable):
                 part.append(deferrable)
-            field_output.append(' '.join(part))
+                sql += [
                     defferable
+                ]
-        return " ".join(field_output)
+        return " ".join(sql)
     def _order_with_respect_field_sql(self):
         """
         Generates the sql for the order_with_respect_to field.
         """
         style = self.style
         return " ".join([
             style.SQL_FIELD(qn('_order')),
             style.SQL_COLTYPE(models.IntegerField().db_type()),
             style.SQL_FIELD( qn('_order') ),
             style.SQL_COLTYPE( models.IntegerField().db_type() ),
             style.SQL_KEYWORD('NULL'),
         ])
     def _unique_statement_sql(self, opts, field_constraints):
         """
         Generates the sql for specifying unique fields.
         """
         style = self.style
         return '%s (%s)' % (
             style.SQL_KEYWORD('UNIQUE'),
             ", ".join([style.SQL_FIELD(qn(opts.get_field(f).column)) for f in field_constraints]),
+        )
     def _model_sql(self, model):
         """
         Generates the sql for the model.
         """
         from django.db import models
         style = no_style()
         opts = model._meta
@@ -182,16 +296,16 @@ class DatabaseManagerBase(object):
             fields.append(self._order_with_respect_field_sql())
         for field_constraints in opts.unique_together:
-            fields.append( self._unique_statement_sql(opts, field_constraints) )
+            fields.append(self._unique_statement_sql(opts, field_constraints))
         sql = [
             style.SQL_KEYWORD('CREATE TABLE'),
             style.SQL_TABLE(qn(opts.db_table)),
             '(\n    %s\n)' % ',\n    '.join(fields),
+        ]
         if opts.has_auto_field:
             # Add any extra SQL needed to support auto-incrementing primary keys.
         # Add any extra SQL needed to support auto-incrementing primary keys.
         if opts.has_auto_field:
             auto_column = opts.auto_field.db_column or opts.auto_field.name
             autoinc_sql = connection.ops.autoinc_sql(opts.db_table, auto_column)
             if autoinc_sql:
@@ -201,15 +315,18 @@ class DatabaseManagerBase(object):
         return " ".join(sql)
     def _m2m_sql(self, model, field):
-        "Return the CREATE TABLE statements for a single m2m field"
+        """
         Generates the sql for a many-to-many field.
         """
         opts = model._meta
         style = self.style
-        tablespace_sql = connection.ops.tablespace_sql(field.db_tablespace or opts.db_tablespace, inline=True)
+        tablespace = field.db_tablespace or opts.db_tablespace
         tablespace_sql = connection.ops.tablespace_sql(tablespace,inline=True)
         auto_sql = [
             style.SQL_FIELD(qn('id')),
             style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type()),
             style.SQL_FIELD( qn('id') ),
             style.SQL_COLTYPE( models.AutoField(primary_key=True).db_type() ),
             style.SQL_KEYWORD('NOT NULL PRIMARY KEY'),
+        ]
         if (tablespace_sql): auto_sql += [ tablespace_sql ]
@@ -266,6 +383,9 @@ class DatabaseManagerBase(object):
         return sql
     def _drop_m2m_sql(self, model, field):
         """
         Generates the sql to drop a many-to-many table.
         """
         style = self.style
         opts = model._meta
@@ -277,6 +397,9 @@ class DatabaseManagerBase(object):
         return " ".join(sql)
     def _rename_m2m_sql(self, model, new_field, old_field):
         """
         Generates the sql to rename a many-to-many table.
         """
         style = self.style
         rename_sql = [
@@ -285,9 +408,21 @@ class DatabaseManagerBase(object):
             style.SQL_KEYWORD('RENAME TO'),
             style.SQL_TABLE( qn(new_field.m2m_db_table()) )
+        ]
         return " ".join(sql)
     def execute(self, description, *sql_statements):
         """
         Executes the sql statements and prints the description to the user,
         unless we are in test mode (see __init__), where the description will
         print but the sql statements won't actually be executed.
         Don't worry about adding a ';' to the end of each statement, it will
         be tacked on.
         Also, each statement can be a list, in which case they are joined by a
         space.
         """
         cursor = connection.cursor()
         if self.verbosity >= 1:
@@ -314,8 +449,9 @@ class DatabaseManagerBase(object):
         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.
         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.
         """
         style = self.style
@@ -342,7 +478,7 @@ class DatabaseManagerBase(object):
         """
         Change a field to the new representation.
-        To rename a field, specify a new_field_name, otherwise leave it None.
+        To rename a field, specify a new_field_name, otherwise ignore it.
         """
         style = self.style
@@ -367,7 +503,11 @@ class DatabaseManagerBase(object):
                 self.drop_field(model_sig, old_field_name)
                 self.execute("Adding many-to-many table for field %s.%s" % (model_sig, new_field_name), self._m2m_sql(model, field))
                 return
-            raise NotImplimentedError("Need to rename the many-to-many field.")
+            if (old.m2m_db_table() != new.m2m_db_table()):
                 self.execute(
                     "Renaming the many-to-many table for field %s.%s" % (model_sig, new_field_name),
                     self._rename_m2m_sql(model, old, field))
                 return
         opts.local_fields = [f for f in opts.local_fields if f != old]
         model.add_to_class(new_field_name, field)
@@ -417,6 +557,11 @@ class DatabaseManagerBase(object):
         self.execute("Dropping field for %s.%s" % (model_sig, field.name), sql)
     def add_model(self, model_sig):
         """
         Adds the model.
         Unless it shows up in self.created_models (see __init__).
         """
         model = models.get_model(*self.parse_sig(model_sig))
         if (model in self.created_models):
@@ -430,6 +575,9 @@ class DatabaseManagerBase(object):
             self.execute("Adding many-to-many table for field %s.%s" % (model_sig, field.name), self._m2m_sql(model, field))
     def rename_model(self, model_sig, new_sig):
         """
         Rename a model.
         """
         old_model = self[model_sig]
         app_name, model_name = self.parse_sig(new_sig)
@@ -438,23 +586,29 @@ class DatabaseManagerBase(object):
         style = self.style
         # Have to drop the one created by the sync db.  TODO: Add ManyToMany support.
         drop_sql = [
         # Have to drop the one created by the sync db.
         # TODO: Add ManyToMany support.
         # TODO: Check through self.created_models before doing this.
         sql = [
             style.SQL_KEYWORD('DROP TABLE'),
             style.SQL_TABLE(qn(new_model._meta.db_table))
+        ]
-        rename_sql = [
+        self.execute('Dropping eroneously created table for %s.' % new_sig, sql)
         sql = [
             style.SQL_KEYWORD('ALTER TABLE'),
             style.SQL_TABLE(qn(old_model._meta.db_table)),
             style.SQL_KEYWORD('RENAME TO'),
             style.SQL_TABLE(qn(new_model._meta.db_table))
+        ]
         self.execute('Dropping eroneously created table for %s.' % new_sig, drop_sql)
         self.execute("Renaming model %s to %s." % (model_sig, new_sig), rename_sql)
         self.execute("Renaming model %s to %s." % (model_sig, new_sig), sql)
     def drop_model(self, model_sig):
         """
         Drops a model.
         """
         model = self[model_sig]
         style = self.style

Up to file-list migratory/manager/sqlite3.py:

@@ -4,12 +4,16 @@ from django.db import connection, models
 qn = connection.ops.quote_name
 class DatabaseManager(DatabaseManagerBase):
     """
     SQLite //seems// like a good idea, until here.  Since it does not support
     propper ALTER TABLE syntax, we must fuss around a lot.
     """
     def add_field(self, model_sig, name):
         """
             SQLite3 doesn't support a general ALTER TABLE syntax.  So we have to
             create a temporary table, move the values into that, then create
             a new table with our added field, and move the values back to it.
             Hurray!
         We haveto create a temporary table, move the values into that, then
         create a new table with our added field, and move the values back
         to it. Hurray!
         """
         app_name, model_name = self.parse_sig(model_sig)
@@ -53,11 +57,13 @@ class DatabaseManager(DatabaseManagerBas
         default = 'NULL'
         if (field.has_default()):
             if (field.rel):
-                default = repr( field.get_db_prep_save(field.default._get_pk_val()) )   # TODO: repr is wrong, what do we do here?
+                # TODO: repr is wrong, what do we do here?
                 val = field.get_db_prep_save(field.default._get_pk_val())
                 default = repr( val )
             else:
                 default = field.get_db_prep_save(field.get_default())
-        # Figure out the new column order, and add the default to the new hole.
+        # Figure out new column order, and add the default to the new hole.
         fieldset = set(fields)
         columns = []
         for f in opts.local_fields:
@@ -90,8 +96,8 @@ class DatabaseManager(DatabaseManagerBas
     def change_field(self, model_sig, old_field_name, new_field_name=None):
         """
             SQLite3 doesn't support a general ALTER TABLE syntax.  So we have to do
             what we do above for add_field and drop_field.
             SQLite3 doesn't support a general ALTER TABLE syntax.  So we
             have to do what we do above for add_field and drop_field.
         """
         if not new_field_name:

Up to file-list migratory/matchmaker.py:

 """
 Defines ways of matching up to sets of objects using an arbitrary comparison
 function.
 matchmaker() and compare_strings() are the functions of note here.
 """
 from array import array
 from bisect import insort
 try:
@@ -9,10 +16,13 @@ def levenshtein(a, b):
     """
     Levenshtein string distance algorithm from:
     http://en.wikibooks.org/wiki/Algorithm_implementation/Strings/Levenshtein_distance
     Well, this is the Lisp implimentation, the python one was amazingly elegant, and
     so, shreaded the stack.  This one uses the table algorithm rather than recursion.
     Well, this is the Lisp implimentation, the python one was amazingly
     elegant, and so, shreaded the stack.  This one uses the table version of
     this algorithm rather than the recursive one.
-    It computes the number of insertions or deletions needed to get from a to b.
+    It computes the number of insertions or deletions needed to get from
     strings a to b.
     """
     len_a, len_b = len(a), len(b)
@@ -52,9 +62,9 @@ def compare_strings(a, b):
 def matchmaker(a, b, compareFunc, threshold=.25):
     """
     Creates a list of matches for the two lists, using the compareFunc as the
     test. It does this by going through and comparing each element in a to each
     element in b, and then deciding based on the coefficient returned from
-    compareFunc, which elements in a 'match up' with those in 'b'.
+    test. It does this by going through and comparing each element in a to
     each element in b, and then deciding based on the coefficient returned
     from compareFunc, which elements in a 'match up' with those in 'b'.
     In terms of people, imagine a list of heterosexual males and females,
     compareFunc spits out a percentage likelihood that the any given
@@ -93,61 +103,3 @@ def matchmaker(a, b, compareFunc, thresh
         males.remove(male)
     return matches, list(females), list(males)
 def test_random(males, females):
     import random
     random.seed(1)
     def comparison(a, b):
         return random.random()
     matches, lonely, _ = matchmaker(males, females, comparison, .75)
     matches = dict(matches)
     assert matches['christopher'] == 'linda'
     assert matches['thomas'] == 'maria'
     assert matches['william'] == 'susan'
     assert 'michael' in lonely
     assert 'daniel' in lonely
     print "Passed."
 def test_levenshtein(males, females):
     print matchmaker(males, females, compare_strings, .25)
 if __name__ == '__main__':
     males = [
         'james',
         'john',
         'robert',
         'michael',
         'william',
         'david',
         'richard',
         'charles',
         'joseph',
         'thomas',
         'christopher',
         'daniel',
+    ]
     females = [
         'mary',
         'patricia',
         'linda',
         'barbara',
         'elizabeth',
         'jennifer',
         'maria',
         'susan',
         'margaret',
         'dorothy',
         'lisa',
         'nancy',
         'karen',
+    ]
     test_random(males, females)
     import cProfile
     def go():
         test_levenshtein(males, females)
     cProfile.run('go()')

Up to file-list migratory/migrate.py:

 """
 Performs any new migrations.
 This is not to be confused with the ./manage.py command which creates
 migration files rather than actually performing them.
 """
 import os
 from django.contrib.migratory.models import Snapshot, Migration
-def do_migrations(sender=None, app=None, created_models=None, verbosity=None, interactive=None, signal=None, **_):
+def do_migrations(sender=None,
                   app=None,
                   created_models=None,
                   verbosity=None,
                   interactive=None,
                   signal=None,
                   **_):
     """
     Performs all new migrations after ./manage.py syncdb.
     This is connected to the post_syncdb in the models.py file.
     """
     from django.contrib.migratory.manager import DatabaseManager
     from django.contrib.migratory.models import Snapshot, Migration
     if (verbosity > 1):
         print "\tChecking for migrations...",
@@ -13,7 +30,9 @@ def do_migrations(sender=None, app=None,
     if (verbosity > 1): print "%s found." % len(migrations.keys())
     if migrations:
-        database_manager = DatabaseManager(app_name, verbosity=verbosity, created_models=created_models)
+        database_manager = DatabaseManager(app_name,
                                            verbosity=verbosity,
                                            created_models=created_models)
         for name, path in migrations.items():
             if (verbosity >= 1): print "Executing migration %r..." % name
@@ -22,7 +41,8 @@ def do_migrations(sender=None, app=None,
 def run_migration(path, database_manager, verbosity):
     if not os.path.exists(path):
-        raise RuntimeError("Unable to find migration at the given path: %r" % path)
+        raise RuntimeError(
             "Unable to find migration at the given path: %r" % path)
     o = open(path)
     src = o.read()
@@ -59,6 +79,8 @@ def run_migration(path, database_manager
         print "Nevermind, no up() defined."
 def get_migrations(app, verbosity):
     from django.contrib.migratory.models import Snapshot, Migration
     app_name = app.__name__.split('.')[-2]
     folder = os.path.join(os.path.dirname(app.__file__), 'migrations')
@@ -68,7 +90,8 @@ def get_migrations(app, verbosity):
     manifest = eval(open(manifest).read())
     if Snapshot.objects.filter(app=app_name).count() == 0:
-        # Since we don't have a snapshot, the app is being created, and so all migrations should be marked as done.
+        # Since we don't have a snapshot, the app is being created, and so all
         # migrations should be marked as done.
         for name in manifest:
             if (verbosity >= 1): print "Assuming migrating %r..." % name
             Migration.objects.get_or_create(name=name)
@@ -80,7 +103,7 @@ def get_migrations(app, verbosity):
         if Migration.objects.filter(name=migration).count() > 0:
             continue
         if not os.path.exists(path):
-            raise RuntimeError("Cannot find a migration present in the __manifest__.py file.")
+            raise RuntimeError( "Cannot find a migration present in the __manifest__.py file.")
         gather[migration] = path
     return gather

Up to file-list migratory/models.py:

@@ -7,7 +7,10 @@ class Snapshot(models.Model):
     app = models.CharField(max_length=255)
     def __unicode__(self):
-        return "Snapshot of %r on %s" % (str(self.app), DateFormat(self.created).format("F jS"))
+        return "Snapshot of %r on %s" % (
             str(self.app),
             DateFormat(self.created).format("F jS")
+        )
 class Migration(models.Model):
     name = models.CharField(max_length=255)

Up to file-list migratory/snapshot.py:

 """
 Handling of 'snapshots' or representations of application models that are
 saved in the database.
 """
 from django.utils import simplejson
 from django.db import models
 from django.db.models.fields import NOT_PROVIDED
 from django.contrib.migratory.models import Snapshot
-def create_snapshots(sender=None, app=None, created_models=None, verbosity=None, interactive=None, signal=None, **_):
+def create_snapshots(sender=None,
                      app=None,
                      created_models=None,
                      verbosity=None,
                      interactive=None,
                      signal=None,
                      **_):
     """
     Creates snapshots of the all models in the triggered app.
     """
     from django.contrib.migratory.models import Snapshot
     app_name = app.__name__.split('.')[-2]
     if (verbosity > 1):
@@ -22,6 +38,17 @@ def create_snapshots(sender=None, app=No
     snapshot.save()
 def model_snap(model):
     """
     Create a snapshot (at this point just a dictionary) of the model by
     analyzing its fields and attributes.
     If we could edit the django source, it would be best for the model to
     create a snapshot of itself.  At initialization, it could record all of
     its options and save them away.  As it stands, we have to manually go
     through and infer options by attributes.
     TODO: Handle 'proxy' values.
     """
     opts = model._meta
     if (opts.order_with_respect_to):
@@ -29,6 +56,8 @@ def model_snap(model):
     else:
         order_with_respect_to = None
     all_fields = opts.local_fields + opts.many_to_many
     return {
         'name': model._meta.object_name,
         'module': model.__module__,
@@ -41,15 +70,27 @@ def model_snap(model):
             'ordering': opts.ordering,
             'permissions': opts.permissions,
             'verbose_name': opts.verbose_name_raw,
             #'verbose_name_plural': opts.verbose_name_plural,  # __proxy__ wha?
             # __proxy__ wha?
             #'verbose_name_plural': opts.verbose_name_plural,
         },
-        'fields': [field_snap(f, model) for f in opts.fields + opts.many_to_many]
+        'fields': [field_snap(f, model) for f in all_fields]
+    }
 def field_snap(field, model):
     """
     Grabs a dictionary snapshot of the field.
     This one is particularly hard, because we can't know for sure what options
     were given to the field on init.  The best we can do is go through a list
     of known options, defined below as 'FIELD_OPTIONS'.
     The Django field base should really provide a better mechanism for this.
     It wouldn't be too hard, and might help codify the system.
     """
     gather = {}
-    for k in field_attrs:
+    for k in FIELD_OPTIONS:
         if hasattr(field, k):
             v = getattr(field, k)
             if hasattr(v, '__promise__'):
@@ -66,7 +107,8 @@ def field_snap(field, model):
     gather['__class__'] = field.__class__.__name__
     return gather
 field_attrs = [
 # Known field attributes that can be regarded as options in the constructor.
 FIELD_OPTIONS = [
     # Base
     'name',
     'null',

commit 4:	cf4e00170a7e
parent 3:	0f4bf0d7e686
branch:	default