Tooltron

        'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.

        'NAME': 'crm',                      # Or path to database file if using sqlite3.

        'USER': 'crmuser',                      # Not used with sqlite3.

        'PASSWORD': 'baseball',                  # Not used with sqlite3.

TIME_ZONE = 'America/New_York'

    'south',

Metadata-Version: 1.0

Name: South

Version: 0.7.6

Summary: South: Migrations for Django

Home-page: http://south.aeracode.org/

Author: Andrew Godwin & Andy McCurdy

Author-email: south@aeracode.org

License: UNKNOWN

Download-URL: http://south.aeracode.org/wiki/Download

Description: South is an intelligent database migrations library for the Django web framework. It is database-independent and DVCS-friendly, as well as a whole host of other features.

Platform: UNKNOWN

Classifier: Development Status :: 5 - Production/Stable

Classifier: Framework :: Django

Classifier: Intended Audience :: Developers

Classifier: Intended Audience :: System Administrators

Classifier: Intended Audience :: System Administrators

Classifier: License :: OSI Approved :: Apache Software License

Classifier: Operating System :: OS Independent

Classifier: Topic :: Software Development

README

setup.cfg

setup.py

South.egg-info/PKG-INFO

South.egg-info/SOURCES.txt

South.egg-info/dependency_links.txt

South.egg-info/top_level.txt

south/__init__.py

south/exceptions.py

south/logger.py

south/models.py

south/modelsinspector.py

south/orm.py

south/signals.py

south/v2.py

south/creator/__init__.py

south/creator/actions.py

south/creator/changes.py

south/creator/freezer.py

south/db/__init__.py

south/db/firebird.py

south/db/generic.py

south/db/mysql.py

south/db/oracle.py

south/db/postgresql_psycopg2.py

south/db/sqlite3.py

south/db/sql_server/__init__.py

south/db/sql_server/pyodbc.py

south/hacks/__init__.py

south/hacks/django_1_0.py

south/introspection_plugins/__init__.py

south/introspection_plugins/annoying_autoonetoone.py

south/introspection_plugins/django_audit_log.py

south/introspection_plugins/django_objectpermissions.py

south/introspection_plugins/django_tagging.py

south/introspection_plugins/django_taggit.py

south/introspection_plugins/django_timezones.py

south/introspection_plugins/geodjango.py

south/management/__init__.py

south/management/commands/__init__.py

south/management/commands/convert_to_south.py

south/management/commands/datamigration.py

south/management/commands/graphmigrations.py

south/management/commands/migrate.py

south/management/commands/migrationcheck.py

south/management/commands/schemamigration.py

south/management/commands/startmigration.py

south/management/commands/syncdb.py

south/management/commands/test.py

south/management/commands/testserver.py

south/migration/__init__.py

south/migration/base.py

south/migration/migrators.py

south/migration/utils.py

south/tests/__init__.py

south/tests/autodetection.py

south/tests/db.py

south/tests/db_mysql.py

south/tests/freezer.py

south/tests/inspector.py

south/tests/logger.py

south/tests/logic.py

south/tests/brokenapp/__init__.py

south/tests/brokenapp/models.py

south/tests/brokenapp/migrations/0001_depends_on_unmigrated.py

south/tests/brokenapp/migrations/0002_depends_on_unknown.py

south/tests/brokenapp/migrations/0003_depends_on_higher.py

south/tests/brokenapp/migrations/0004_higher.py

south/tests/brokenapp/migrations/__init__.py

south/tests/circular_a/__init__.py

south/tests/circular_a/models.py

south/tests/circular_a/migrations/0001_first.py

south/tests/circular_a/migrations/__init__.py

south/tests/circular_b/__init__.py

south/tests/circular_b/models.py

south/tests/circular_b/migrations/0001_first.py

south/tests/circular_b/migrations/__init__.py

south/tests/deps_a/__init__.py

south/tests/deps_a/models.py

south/tests/deps_a/migrations/0001_a.py

south/tests/deps_a/migrations/0002_a.py

south/tests/deps_a/migrations/0003_a.py

south/tests/deps_a/migrations/0004_a.py

south/tests/deps_a/migrations/0005_a.py

south/tests/deps_a/migrations/__init__.py

south/tests/deps_b/__init__.py

south/tests/deps_b/models.py

south/tests/deps_b/migrations/0001_b.py

south/tests/deps_b/migrations/0002_b.py

south/tests/deps_b/migrations/0003_b.py

south/tests/deps_b/migrations/0004_b.py

south/tests/deps_b/migrations/0005_b.py

south/tests/deps_b/migrations/__init__.py

south/tests/deps_c/__init__.py

south/tests/deps_c/models.py

south/tests/deps_c/migrations/0001_c.py

south/tests/deps_c/migrations/0002_c.py

south/tests/deps_c/migrations/0003_c.py

south/tests/deps_c/migrations/0004_c.py

south/tests/deps_c/migrations/0005_c.py

south/tests/deps_c/migrations/__init__.py

south/tests/emptyapp/__init__.py

south/tests/emptyapp/models.py

south/tests/emptyapp/migrations/__init__.py

south/tests/fakeapp/__init__.py

south/tests/fakeapp/models.py

south/tests/fakeapp/migrations/0001_spam.py

south/tests/fakeapp/migrations/0002_eggs.py

south/tests/fakeapp/migrations/0003_alter_spam.py

south/tests/fakeapp/migrations/__init__.py

south/tests/non_managed/__init__.py

south/tests/non_managed/models.py

south/tests/non_managed/migrations/__init__.py

south/tests/otherfakeapp/__init__.py

south/tests/otherfakeapp/models.py

south/tests/otherfakeapp/migrations/0001_first.py

south/tests/otherfakeapp/migrations/0002_second.py

south/tests/otherfakeapp/migrations/0003_third.py

south/tests/otherfakeapp/migrations/__init__.py

south/utils/__init__.py

south/utils/datetime_utils.py

../south/orm.py

../south/exceptions.py

../south/signals.py

../south/modelsinspector.py

../south/logger.py

../south/__init__.py

../south/models.py

../south/v2.py

../south/creator/freezer.py

../south/creator/changes.py

../south/creator/__init__.py

../south/creator/actions.py

../south/db/firebird.py

../south/db/postgresql_psycopg2.py

../south/db/sqlite3.py

../south/db/__init__.py

../south/db/oracle.py

../south/db/mysql.py

../south/db/generic.py

../south/management/__init__.py

../south/introspection_plugins/geodjango.py

../south/introspection_plugins/django_timezones.py

../south/introspection_plugins/annoying_autoonetoone.py

../south/introspection_plugins/django_audit_log.py

../south/introspection_plugins/__init__.py

../south/introspection_plugins/django_tagging.py

../south/introspection_plugins/django_objectpermissions.py

../south/introspection_plugins/django_taggit.py

../south/hacks/__init__.py

../south/hacks/django_1_0.py

../south/migration/migrators.py

../south/migration/utils.py

../south/migration/base.py

../south/migration/__init__.py

../south/tests/freezer.py

../south/tests/autodetection.py

../south/tests/logger.py

../south/tests/logic.py

../south/tests/inspector.py

../south/tests/__init__.py

../south/tests/db.py

../south/tests/db_mysql.py

../south/db/sql_server/pyodbc.py

../south/db/sql_server/__init__.py

../south/management/commands/syncdb.py

../south/management/commands/graphmigrations.py

../south/management/commands/schemamigration.py

../south/management/commands/test.py

../south/management/commands/migrationcheck.py

../south/management/commands/testserver.py

../south/management/commands/convert_to_south.py

../south/management/commands/datamigration.py

../south/management/commands/__init__.py

../south/management/commands/migrate.py

../south/management/commands/startmigration.py

../south/tests/circular_a/__init__.py

../south/tests/circular_a/models.py

../south/tests/emptyapp/__init__.py

../south/tests/emptyapp/models.py

../south/tests/deps_a/__init__.py

../south/tests/deps_a/models.py

../south/tests/fakeapp/__init__.py

../south/tests/fakeapp/models.py

../south/tests/brokenapp/__init__.py

../south/tests/brokenapp/models.py

../south/tests/circular_b/__init__.py

../south/tests/circular_b/models.py

../south/tests/otherfakeapp/__init__.py

../south/tests/otherfakeapp/models.py

../south/tests/deps_c/__init__.py

../south/tests/deps_c/models.py

../south/tests/deps_b/__init__.py

../south/tests/deps_b/models.py

../south/tests/non_managed/__init__.py

../south/tests/non_managed/models.py

../south/tests/circular_a/migrations/__init__.py

../south/tests/circular_a/migrations/0001_first.py

../south/tests/emptyapp/migrations/__init__.py

../south/tests/deps_a/migrations/0002_a.py

../south/tests/deps_a/migrations/0005_a.py

../south/tests/deps_a/migrations/__init__.py

../south/tests/deps_a/migrations/0004_a.py

../south/tests/deps_a/migrations/0001_a.py

../south/tests/deps_a/migrations/0003_a.py

../south/tests/fakeapp/migrations/0002_eggs.py

../south/tests/fakeapp/migrations/__init__.py

../south/tests/fakeapp/migrations/0003_alter_spam.py

../south/tests/fakeapp/migrations/0001_spam.py

../south/tests/brokenapp/migrations/0004_higher.py

../south/tests/brokenapp/migrations/0002_depends_on_unknown.py

../south/tests/brokenapp/migrations/__init__.py

../south/tests/brokenapp/migrations/0001_depends_on_unmigrated.py

../south/tests/brokenapp/migrations/0003_depends_on_higher.py

../south/tests/circular_b/migrations/__init__.py

../south/tests/circular_b/migrations/0001_first.py

../south/tests/otherfakeapp/migrations/0002_second.py

../south/tests/otherfakeapp/migrations/__init__.py

../south/tests/otherfakeapp/migrations/0003_third.py

../south/tests/otherfakeapp/migrations/0001_first.py

../south/tests/deps_c/migrations/0003_c.py

../south/tests/deps_c/migrations/0005_c.py

../south/tests/deps_c/migrations/__init__.py

../south/tests/deps_c/migrations/0002_c.py

../south/tests/deps_c/migrations/0001_c.py

../south/tests/deps_c/migrations/0004_c.py

../south/tests/deps_b/migrations/0005_b.py

../south/tests/deps_b/migrations/0002_b.py

../south/tests/deps_b/migrations/__init__.py

../south/tests/deps_b/migrations/0004_b.py

../south/tests/deps_b/migrations/0003_b.py

../south/tests/deps_b/migrations/0001_b.py

../south/tests/non_managed/migrations/__init__.py

../south/utils/__init__.py

../south/utils/datetime_utils.py

../south/orm.pyc

../south/exceptions.pyc

../south/signals.pyc

../south/modelsinspector.pyc

../south/logger.pyc

../south/__init__.pyc

../south/models.pyc

../south/v2.pyc

../south/creator/freezer.pyc

../south/creator/changes.pyc

../south/creator/__init__.pyc

../south/creator/actions.pyc

../south/db/firebird.pyc

../south/db/postgresql_psycopg2.pyc

../south/db/sqlite3.pyc

../south/db/__init__.pyc

../south/db/oracle.pyc

../south/db/mysql.pyc

../south/db/generic.pyc

../south/management/__init__.pyc

../south/introspection_plugins/geodjango.pyc

../south/introspection_plugins/django_timezones.pyc

../south/introspection_plugins/annoying_autoonetoone.pyc

../south/introspection_plugins/django_audit_log.pyc

../south/introspection_plugins/__init__.pyc

../south/introspection_plugins/django_tagging.pyc

../south/introspection_plugins/django_objectpermissions.pyc

../south/introspection_plugins/django_taggit.pyc

../south/hacks/__init__.pyc

../south/hacks/django_1_0.pyc

../south/migration/migrators.pyc

../south/migration/utils.pyc

../south/migration/base.pyc

../south/migration/__init__.pyc

../south/tests/freezer.pyc

../south/tests/autodetection.pyc

../south/tests/logger.pyc

../south/tests/logic.pyc

../south/tests/inspector.pyc

../south/tests/__init__.pyc

../south/tests/db.pyc

../south/tests/db_mysql.pyc

../south/db/sql_server/pyodbc.pyc

../south/db/sql_server/__init__.pyc

../south/management/commands/syncdb.pyc

../south/management/commands/graphmigrations.pyc

../south/management/commands/schemamigration.pyc

../south/management/commands/test.pyc

../south/management/commands/migrationcheck.pyc

../south/management/commands/testserver.pyc

../south/management/commands/convert_to_south.pyc

../south/management/commands/datamigration.pyc

../south/management/commands/__init__.pyc

../south/management/commands/migrate.pyc

../south/management/commands/startmigration.pyc

../south/tests/circular_a/__init__.pyc

../south/tests/circular_a/models.pyc

../south/tests/emptyapp/__init__.pyc

../south/tests/emptyapp/models.pyc

../south/tests/deps_a/__init__.pyc

../south/tests/deps_a/models.pyc

../south/tests/fakeapp/__init__.pyc

../south/tests/fakeapp/models.pyc

../south/tests/brokenapp/__init__.pyc

../south/tests/brokenapp/models.pyc

../south/tests/circular_b/__init__.pyc

../south/tests/circular_b/models.pyc

../south/tests/otherfakeapp/__init__.pyc

../south/tests/otherfakeapp/models.pyc

../south/tests/deps_c/__init__.pyc

../south/tests/deps_c/models.pyc

../south/tests/deps_b/__init__.pyc

../south/tests/deps_b/models.pyc

../south/tests/non_managed/__init__.pyc

../south/tests/non_managed/models.pyc

../south/tests/circular_a/migrations/__init__.pyc

../south/tests/circular_a/migrations/0001_first.pyc

../south/tests/emptyapp/migrations/__init__.pyc

../south/tests/deps_a/migrations/0002_a.pyc

../south/tests/deps_a/migrations/0005_a.pyc

../south/tests/deps_a/migrations/__init__.pyc

../south/tests/deps_a/migrations/0004_a.pyc

../south/tests/deps_a/migrations/0001_a.pyc

../south/tests/deps_a/migrations/0003_a.pyc

../south/tests/fakeapp/migrations/0002_eggs.pyc

../south/tests/fakeapp/migrations/__init__.pyc

../south/tests/fakeapp/migrations/0003_alter_spam.pyc

../south/tests/fakeapp/migrations/0001_spam.pyc

../south/tests/brokenapp/migrations/0004_higher.pyc

../south/tests/brokenapp/migrations/0002_depends_on_unknown.pyc

../south/tests/brokenapp/migrations/__init__.pyc

../south/tests/brokenapp/migrations/0001_depends_on_unmigrated.pyc

../south/tests/brokenapp/migrations/0003_depends_on_higher.pyc

../south/tests/circular_b/migrations/__init__.pyc

../south/tests/circular_b/migrations/0001_first.pyc

../south/tests/otherfakeapp/migrations/0002_second.pyc

../south/tests/otherfakeapp/migrations/__init__.pyc

../south/tests/otherfakeapp/migrations/0003_third.pyc

../south/tests/otherfakeapp/migrations/0001_first.pyc

../south/tests/deps_c/migrations/0003_c.pyc

../south/tests/deps_c/migrations/0005_c.pyc

../south/tests/deps_c/migrations/__init__.pyc

../south/tests/deps_c/migrations/0002_c.pyc

../south/tests/deps_c/migrations/0001_c.pyc

../south/tests/deps_c/migrations/0004_c.pyc

../south/tests/deps_b/migrations/0005_b.pyc

../south/tests/deps_b/migrations/0002_b.pyc

../south/tests/deps_b/migrations/__init__.pyc

../south/tests/deps_b/migrations/0004_b.pyc

../south/tests/deps_b/migrations/0003_b.pyc

../south/tests/deps_b/migrations/0001_b.pyc

../south/tests/non_managed/migrations/__init__.pyc

../south/utils/__init__.pyc

../south/utils/datetime_utils.pyc

./

top_level.txt

SOURCES.txt

PKG-INFO

dependency_links.txt

south

"""

South - Useable migrations for Django apps

"""

__version__ = "0.7.6"

__authors__ = [

    "Andrew Godwin <andrew@aeracode.org>",

    "Andy McCurdy <andy@andymccurdy.com>"

]

"""

The creator module is responsible for making new migration files, either

as blank templates or autodetecting changes. It contains code that used to

all be in startmigration.py.

"""

"""

Actions - things like 'a model was removed' or 'a field was changed'.

Each one has a class, which can take the action description and insert code

blocks into the forwards() and backwards() methods, in the right place.

"""

import sys

from django.db.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT

from django.db.models.fields import FieldDoesNotExist, NOT_PROVIDED, CharField, TextField

from south.modelsinspector import value_clean

from south.creator.freezer import remove_useless_attributes, model_key

from south.utils import datetime_utils

class Action(object):

    """

    Generic base Action class. Contains utility methods for inserting into

    the forwards() and backwards() method lists.

    """

    prepend_forwards = False

    prepend_backwards = False

    def forwards_code(self):

        raise NotImplementedError

    def backwards_code(self):

        raise NotImplementedError

    def add_forwards(self, forwards):

        if self.prepend_forwards:

            forwards.insert(0, self.forwards_code())

        else:

            forwards.append(self.forwards_code())

    def add_backwards(self, backwards):

        if self.prepend_backwards:

            backwards.insert(0, self.backwards_code())

        else:

            backwards.append(self.backwards_code())

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        raise NotImplementedError

    @classmethod

    def triples_to_defs(cls, fields):

        # Turn the (class, args, kwargs) format into a string

        for field, triple in fields.items():

            fields[field] = cls.triple_to_def(triple)

        return fields

    @classmethod

    def triple_to_def(cls, triple):

        "Turns a single triple into a definition."

        return "self.gf(%r)(%s)" % (

            triple[0], # Field full path

            ", ".join(triple[1] + ["%s=%s" % (kwd, val) for kwd, val in triple[2].items()]), # args and kwds

        )

class AddModel(Action):

    """

    Addition of a model. Takes the Model subclass that is being created.

    """

    FORWARDS_TEMPLATE = '''

        # Adding model '%(model_name)s'

        db.create_table(%(table_name)r, (

            %(field_defs)s

        ))

        db.send_create_signal(%(app_label)r, [%(model_name)r])'''[1:] + "\n"

    BACKWARDS_TEMPLATE = '''

        # Deleting model '%(model_name)s'

        db.delete_table(%(table_name)r)'''[1:] + "\n"

    def __init__(self, model, model_def):

        self.model = model

        self.model_def = model_def

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " + Added model %s.%s" % (

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        "Produces the code snippet that gets put into forwards()"

        field_defs = ",\n            ".join([

            "(%r, %s)" % (name, defn) for name, defn

            in self.triples_to_defs(self.model_def).items()

        ]) + ","

        return self.FORWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "app_label": self.model._meta.app_label,

            "field_defs": field_defs,

        }

    def backwards_code(self):

        "Produces the code snippet that gets put into backwards()"

        return self.BACKWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

        }

class DeleteModel(AddModel):

    """

    Deletion of a model. Takes the Model subclass that is being created.

    """

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " - Deleted model %s.%s" % (

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return AddModel.backwards_code(self)

    def backwards_code(self):

        return AddModel.forwards_code(self)

class _NullIssuesField(object):

    """

    A field that might need to ask a question about rogue NULL values.

    """

    allow_third_null_option = False

    irreversible = False

    IRREVERSIBLE_TEMPLATE = '''

        # User chose to not deal with backwards NULL issues for '%(model_name)s.%(field_name)s'

        raise RuntimeError("Cannot reverse this migration. '%(model_name)s.%(field_name)s' and its values cannot be restored.")'''

    def deal_with_not_null_no_default(self, field, field_def):

        # If it's a CharField or TextField that's blank, skip this step.

        if isinstance(field, (CharField, TextField)) and field.blank:

            field_def[2]['default'] = repr("")

            return

        # Oh dear. Ask them what to do.

        print " ? The field '%s.%s' does not have a default specified, yet is NOT NULL." % (

            self.model._meta.object_name,

            field.name,

        )

        print " ? Since you are %s, you MUST specify a default" % self.null_reason

        print " ? value to use for existing rows. Would you like to:"

        print " ?  1. Quit now, and add a default to the field in models.py"

        print " ?  2. Specify a one-off value to use for existing columns now"

        if self.allow_third_null_option:

            print " ?  3. Disable the backwards migration by raising an exception."

        while True:

            choice = raw_input(" ? Please select a choice: ")

            if choice == "1":

                sys.exit(1)

            elif choice == "2":

                break

            elif choice == "3" and self.allow_third_null_option:

                break

            else:

                print " ! Invalid choice."

        if choice == "2":

            self.add_one_time_default(field, field_def)

        elif choice == "3":

            self.irreversible = True

    def add_one_time_default(self, field, field_def):

        # OK, they want to pick their own one-time default. Who are we to refuse?

        print " ? Please enter Python code for your one-off default value."

        print " ? The datetime module is available, so you can do e.g. datetime.date.today()"

        while True:

            code = raw_input(" >>> ")

            if not code:

                print " ! Please enter some code, or 'exit' (with no quotes) to exit."

            elif code == "exit":

                sys.exit(1)

            else:

                try:

                    result = eval(code, {}, {"datetime": datetime_utils})

                except (SyntaxError, NameError), e:

                    print " ! Invalid input: %s" % e

                else:

                    break

        # Right, add the default in.

        field_def[2]['default'] = value_clean(result)

    def irreversable_code(self, field):

        return self.IRREVERSIBLE_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "field_name": field.name,

            "field_column": field.column,

        }

class AddField(Action, _NullIssuesField):

    """

    Adds a field to a model. Takes a Model class and the field name.

    """

    null_reason = "adding this field"

    FORWARDS_TEMPLATE = '''

        # Adding field '%(model_name)s.%(field_name)s'

        db.add_column(%(table_name)r, %(field_name)r,

                      %(field_def)s,

                      keep_default=False)'''[1:] + "\n"

    BACKWARDS_TEMPLATE = '''

        # Deleting field '%(model_name)s.%(field_name)s'

        db.delete_column(%(table_name)r, %(field_column)r)'''[1:] + "\n"

    def __init__(self, model, field, field_def):

        self.model = model

        self.field = field

        self.field_def = field_def

        # See if they've made a NOT NULL column but also have no default (far too common)

        is_null = self.field.null

        default = (self.field.default is not None) and (self.field.default is not NOT_PROVIDED)

        if not is_null and not default:

            self.deal_with_not_null_no_default(self.field, self.field_def)

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " + Added field %s on %s.%s" % (

            self.field.name,

            self.model._meta.app_label,

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return self.FORWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "field_name": self.field.name,

            "field_column": self.field.column,

            "field_def": self.triple_to_def(self.field_def),

        }

    def backwards_code(self):

        return self.BACKWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "field_name": self.field.name,

            "field_column": self.field.column,

        }

class DeleteField(AddField):

    """

    Removes a field from a model. Takes a Model class and the field name.

    """

    null_reason = "removing this field"

    allow_third_null_option = True

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " - Deleted field %s on %s.%s" % (

            self.field.name,

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return AddField.backwards_code(self)

    def backwards_code(self):

        if not self.irreversible:

            return AddField.forwards_code(self)

        else:

            return self.irreversable_code(self.field)

class ChangeField(Action, _NullIssuesField):

    """

    Changes a field's type/options on a model.

    """

    null_reason = "making this field non-nullable"

    FORWARDS_TEMPLATE = BACKWARDS_TEMPLATE = '''

        # Changing field '%(model_name)s.%(field_name)s'

        db.alter_column(%(table_name)r, %(field_column)r, %(field_def)s)'''

    RENAME_TEMPLATE = '''

        # Renaming column for '%(model_name)s.%(field_name)s' to match new field type.

        db.rename_column(%(table_name)r, %(old_column)r, %(new_column)r)'''

    def __init__(self, model, old_field, new_field, old_def, new_def):

        self.model = model

        self.old_field = old_field

        self.new_field = new_field

        self.old_def = old_def

        self.new_def = new_def

        # See if they've changed a not-null field to be null

        new_default = (self.new_field.default is not None) and (self.new_field.default is not NOT_PROVIDED)

        old_default = (self.old_field.default is not None) and (self.old_field.default is not NOT_PROVIDED)

        if self.old_field.null and not self.new_field.null and not new_default:

            self.deal_with_not_null_no_default(self.new_field, self.new_def)

        if not self.old_field.null and self.new_field.null and not old_default:

            self.null_reason = "making this field nullable"

            self.allow_third_null_option = True

            self.deal_with_not_null_no_default(self.old_field, self.old_def)

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " ~ Changed field %s on %s.%s" % (

            self.new_field.name,

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def _code(self, old_field, new_field, new_def):

        output = ""

        if self.old_field.column != self.new_field.column:

            output += self.RENAME_TEMPLATE % {

                "model_name": self.model._meta.object_name,

                "table_name": self.model._meta.db_table,

                "field_name": new_field.name,

                "old_column": old_field.column,

                "new_column": new_field.column,

            }

        output += self.FORWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "field_name": new_field.name,

            "field_column": new_field.column,

            "field_def": self.triple_to_def(new_def),

        }

        return output

    def forwards_code(self):

        return self._code(self.old_field, self.new_field, self.new_def)

    def backwards_code(self):

        if not self.irreversible:

            return self._code(self.new_field, self.old_field, self.old_def)

        else:

            return self.irreversable_code(self.old_field)

class AddUnique(Action):

    """

    Adds a unique constraint to a model. Takes a Model class and the field names.

    """

    FORWARDS_TEMPLATE = '''

        # Adding unique constraint on '%(model_name)s', fields %(field_names)s

        db.create_unique(%(table_name)r, %(fields)r)'''[1:] + "\n"

    BACKWARDS_TEMPLATE = '''

        # Removing unique constraint on '%(model_name)s', fields %(field_names)s

        db.delete_unique(%(table_name)r, %(fields)r)'''[1:] + "\n"

    prepend_backwards = True

    def __init__(self, model, fields):

        self.model = model

        self.fields = fields

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " + Added unique constraint for %s on %s.%s" % (

            [x.name for x in self.fields],

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return self.FORWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "fields":  [field.column for field in self.fields],

            "field_names":  [field.name for field in self.fields],

        }

    def backwards_code(self):

        return self.BACKWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "table_name": self.model._meta.db_table,

            "fields": [field.column for field in self.fields],

            "field_names":  [field.name for field in self.fields],

        }

class DeleteUnique(AddUnique):

    """

    Removes a unique constraint from a model. Takes a Model class and the field names.

    """

    prepend_forwards = True

    prepend_backwards = False

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " - Deleted unique constraint for %s on %s.%s" % (

            [x.name for x in self.fields],

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return AddUnique.backwards_code(self)

    def backwards_code(self):

        return AddUnique.forwards_code(self)

class AddIndex(AddUnique):

    """

    Adds an index to a model field[s]. Takes a Model class and the field names.

    """

    FORWARDS_TEMPLATE = '''

        # Adding index on '%(model_name)s', fields %(field_names)s

        db.create_index(%(table_name)r, %(fields)r)'''[1:] + "\n"

    BACKWARDS_TEMPLATE = '''

        # Removing index on '%(model_name)s', fields %(field_names)s

        db.delete_index(%(table_name)r, %(fields)r)'''[1:] + "\n"

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " + Added index for %s on %s.%s" % (

            [x.name for x in self.fields],

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

class DeleteIndex(AddIndex):

    """

    Deletes an index off a model field[s]. Takes a Model class and the field names.

    """

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " + Deleted index for %s on %s.%s" % (

            [x.name for x in self.fields],

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return AddIndex.backwards_code(self)

    def backwards_code(self):

        return AddIndex.forwards_code(self)

class AddM2M(Action):

    """

    Adds a unique constraint to a model. Takes a Model class and the field names.

    """

    FORWARDS_TEMPLATE = '''

        # Adding M2M table for field %(field_name)s on '%(model_name)s'

        db.create_table(%(table_name)r, (

            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),

            (%(left_field)r, models.ForeignKey(orm[%(left_model_key)r], null=False)),

            (%(right_field)r, models.ForeignKey(orm[%(right_model_key)r], null=False))

        ))

        db.create_unique(%(table_name)r, [%(left_column)r, %(right_column)r])'''[1:] + "\n"

    BACKWARDS_TEMPLATE = '''

        # Removing M2M table for field %(field_name)s on '%(model_name)s'

        db.delete_table('%(table_name)s')'''[1:] + "\n"

    def __init__(self, model, field):

        self.model = model

        self.field = field

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " + Added M2M table for %s on %s.%s" % (

            self.field.name,

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return self.FORWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "field_name": self.field.name,

            "table_name": self.field.m2m_db_table(),

            "left_field": self.field.m2m_column_name()[:-3], # Remove the _id part

            "left_column": self.field.m2m_column_name(),

            "left_model_key": model_key(self.model),

            "right_field": self.field.m2m_reverse_name()[:-3], # Remove the _id part

            "right_column": self.field.m2m_reverse_name(),

            "right_model_key": model_key(self.field.rel.to),

        }

    def backwards_code(self):

        return self.BACKWARDS_TEMPLATE % {

            "model_name": self.model._meta.object_name,

            "field_name": self.field.name,

            "table_name": self.field.m2m_db_table(),

        }

class DeleteM2M(AddM2M):

    """

    Adds a unique constraint to a model. Takes a Model class and the field names.

    """

    def console_line(self):

        "Returns the string to print on the console, e.g. ' + Added field foo'"

        return " - Deleted M2M table for %s on %s.%s" % (

            self.field.name,

            self.model._meta.app_label, 

            self.model._meta.object_name,

        )

    def forwards_code(self):

        return AddM2M.backwards_code(self)

    def backwards_code(self):

        return AddM2M.forwards_code(self)

"""

Contains things to detect changes - either using options passed in on the

commandline, or by using autodetection, etc.

"""

from django.db import models

from django.contrib.contenttypes.generic import GenericRelation

from django.utils.datastructures import SortedDict

from south.creator.freezer import remove_useless_attributes, freeze_apps, model_key

from south.utils import auto_through

class BaseChanges(object):

    """

    Base changes class.

    """

    def suggest_name(self):

        return ''

    def split_model_def(self, model, model_def):

        """

        Given a model and its model def (a dict of field: triple), returns three

        items: the real fields dict, the Meta dict, and the M2M fields dict.

        """

        real_fields = SortedDict()

        meta = SortedDict()

        m2m_fields = SortedDict()

        for name, triple in model_def.items():

            if name == "Meta":

                meta = triple

            elif isinstance(model._meta.get_field_by_name(name)[0], models.ManyToManyField):

                m2m_fields[name] = triple

            else:

                real_fields[name] = triple

        return real_fields, meta, m2m_fields

    def current_model_from_key(self, key):

        app_label, model_name = key.split(".")

        return models.get_model(app_label, model_name)

    def current_field_from_key(self, key, fieldname):

        app_label, model_name = key.split(".")

        # Special, for the magical field from order_with_respect_to

        if fieldname == "_order":

            field = models.IntegerField()

            field.name = "_order"

            field.attname = "_order"

            field.column = "_order"

            field.default = 0

            return field

        # Otherwise, normal.

        return models.get_model(app_label, model_name)._meta.get_field_by_name(fieldname)[0]

class AutoChanges(BaseChanges):

    """

    Detects changes by 'diffing' two sets of frozen model definitions.

    """

    # Field types we don't generate add/remove field changes for.

    IGNORED_FIELD_TYPES = [

        GenericRelation,

    ]

    def __init__(self, migrations, old_defs, old_orm, new_defs):

        self.migrations = migrations

        self.old_defs = old_defs

        self.old_orm = old_orm

        self.new_defs = new_defs

    def suggest_name(self):

        parts = ["auto"]

        for change_name, params in self.get_changes():

            if change_name == "AddModel":

                parts.append("add_%s" % params['model']._meta.object_name.lower())

            elif change_name == "DeleteModel":

                parts.append("del_%s" % params['model']._meta.object_name.lower())

            elif change_name == "AddField":

                parts.append("add_field_%s_%s" % (

                    params['model']._meta.object_name.lower(),

                    params['field'].name,

                ))

            elif change_name == "DeleteField":

                parts.append("del_field_%s_%s" % (

                    params['model']._meta.object_name.lower(),

                    params['field'].name,

                ))

            elif change_name == "ChangeField":

                parts.append("chg_field_%s_%s" % (

                    params['model']._meta.object_name.lower(),

                    params['new_field'].name,

                ))

            elif change_name == "AddUnique":

                parts.append("add_unique_%s_%s" % (

                    params['model']._meta.object_name.lower(),

                    "_".join([x.name for x in params['fields']]),

                ))

            elif change_name == "DeleteUnique":

                parts.append("del_unique_%s_%s" % (

                    params['model']._meta.object_name.lower(),

                    "_".join([x.name for x in params['fields']]),

                ))

        return ("__".join(parts))[:70]

    def get_changes(self):

        """

        Returns the difference between the old and new sets of models as a 5-tuple:

        added_models, deleted_models, added_fields, deleted_fields, changed_fields

        """

        deleted_models = set()

        # See if anything's vanished

        for key in self.old_defs:

            if key not in self.new_defs:

                # We shouldn't delete it if it was managed=False

                old_fields, old_meta, old_m2ms = self.split_model_def(self.old_orm[key], self.old_defs[key])

                if old_meta.get("managed", "True") != "False":

                    # Alright, delete it.

                    yield ("DeleteModel", {

                        "model": self.old_orm[key], 

                        "model_def": old_fields,

                    })

                    # Also make sure we delete any M2Ms it had.

                    for fieldname in old_m2ms:

                        # Only delete its stuff if it wasn't a through=.

                        field = self.old_orm[key + ":" + fieldname]

                        if auto_through(field):

                            yield ("DeleteM2M", {"model": self.old_orm[key], "field": field})

                    # And any unique constraints it had 

                    unique_together = eval(old_meta.get("unique_together", "[]"))

                    if unique_together:

                        # If it's only a single tuple, make it into the longer one

                        if isinstance(unique_together[0], basestring):

                            unique_together = [unique_together]

                        # For each combination, make an action for it

                        for fields in unique_together:

                            yield ("DeleteUnique", {

                                "model": self.old_orm[key],

                                "fields": [self.old_orm[key]._meta.get_field_by_name(x)[0] for x in fields],

                            })

                # We always add it in here so we ignore it later

                deleted_models.add(key)

        # Or appeared

        for key in self.new_defs:

            if key not in self.old_defs:

                # We shouldn't add it if it's managed=False

                new_fields, new_meta, new_m2ms = self.split_model_def(self.current_model_from_key(key), self.new_defs[key])

                if new_meta.get("managed", "True") != "False":

                    yield ("AddModel", {

                        "model": self.current_model_from_key(key), 

                        "model_def": new_fields,

                    })

                    # Also make sure we add any M2Ms it has.

                    for fieldname in new_m2ms:

                        # Only create its stuff if it wasn't a through=.

                        field = self.current_field_from_key(key, fieldname)

                        if auto_through(field):

                            yield ("AddM2M", {"model": self.current_model_from_key(key), "field": field})

                    # And any unique constraints it has 

                    unique_together = eval(new_meta.get("unique_together", "[]"))

                    if unique_together:

                        # If it's only a single tuple, make it into the longer one

                        if isinstance(unique_together[0], basestring):

                            unique_together = [unique_together]

                        # For each combination, make an action for it

                        for fields in unique_together:

                            yield ("AddUnique", {

                                "model": self.current_model_from_key(key),

                                "fields": [self.current_model_from_key(key)._meta.get_field_by_name(x)[0] for x in fields],

                            })

        # Now, for every model that's stayed the same, check its fields.

        for key in self.old_defs:

            if key not in deleted_models:

                old_fields, old_meta, old_m2ms = self.split_model_def(self.old_orm[key], self.old_defs[key])

                new_fields, new_meta, new_m2ms = self.split_model_def(self.current_model_from_key(key), self.new_defs[key])

                # Do nothing for models which are now not managed.

                if new_meta.get("managed", "True") == "False":

                    continue

                # Find fields that have vanished.

                for fieldname in old_fields:

                    if fieldname not in new_fields:

                        # Don't do it for any fields we're ignoring

                        field = self.old_orm[key + ":" + fieldname]

                        field_allowed = True

                        for field_type in self.IGNORED_FIELD_TYPES:

                            if isinstance(field, field_type):

                                field_allowed = False

                        if field_allowed:

                            # Looks alright.

                            yield ("DeleteField", {

                                "model": self.old_orm[key],

                                "field": field,

                                "field_def": old_fields[fieldname],

                            })

                # And ones that have appeared

                for fieldname in new_fields:

                    if fieldname not in old_fields:

                        # Don't do it for any fields we're ignoring

                        field = self.current_field_from_key(key, fieldname)

                        field_allowed = True

                        for field_type in self.IGNORED_FIELD_TYPES:

                            if isinstance(field, field_type):

                                field_allowed = False

                        if field_allowed:

                            # Looks alright.

                            yield ("AddField", {

                                "model": self.current_model_from_key(key),

                                "field": field,

                                "field_def": new_fields[fieldname],

                            })

                # Find M2Ms that have vanished

                for fieldname in old_m2ms:

                    if fieldname not in new_m2ms:

                        # Only delete its stuff if it wasn't a through=.

                        field = self.old_orm[key + ":" + fieldname]

                        if auto_through(field):

                            yield ("DeleteM2M", {"model": self.old_orm[key], "field": field})

                # Find M2Ms that have appeared

                for fieldname in new_m2ms:

                    if fieldname not in old_m2ms:

                        # Only create its stuff if it wasn't a through=.

                        field = self.current_field_from_key(key, fieldname)

                        if auto_through(field):

                            yield ("AddM2M", {"model": self.current_model_from_key(key), "field": field})

                # For the ones that exist in both models, see if they were changed

                for fieldname in set(old_fields).intersection(set(new_fields)):

                    # Non-index changes

                    if self.different_attributes(

                     remove_useless_attributes(old_fields[fieldname], True, True),

                     remove_useless_attributes(new_fields[fieldname], True, True)):

                        yield ("ChangeField", {

                            "model": self.current_model_from_key(key),

                            "old_field": self.old_orm[key + ":" + fieldname],

                            "new_field": self.current_field_from_key(key, fieldname),

                            "old_def": old_fields[fieldname],

                            "new_def": new_fields[fieldname],

                        })

                    # Index changes

                    old_field = self.old_orm[key + ":" + fieldname]

                    new_field = self.current_field_from_key(key, fieldname)

                    if not old_field.db_index and new_field.db_index:

                        # They've added an index.

                        yield ("AddIndex", {

                            "model": self.current_model_from_key(key),

                            "fields": [new_field],

                        })

                    if old_field.db_index and not new_field.db_index:

                        # They've removed an index.

                        yield ("DeleteIndex", {

                            "model": self.old_orm[key],

                            "fields": [old_field],

                        })

                    # See if their uniques have changed

                    if old_field.unique != new_field.unique:

                        # Make sure we look at the one explicitly given to see what happened

                        if new_field.unique:

                            yield ("AddUnique", {

                                "model": self.current_model_from_key(key),

                                "fields": [new_field],

                            })

                        else:

                            yield ("DeleteUnique", {

                                "model": self.old_orm[key],

                                "fields": [old_field],

                            })

                # See if there's any M2Ms that have changed.

                for fieldname in set(old_m2ms).intersection(set(new_m2ms)):

                    old_field = self.old_orm[key + ":" + fieldname]

                    new_field = self.current_field_from_key(key, fieldname)

                    # Have they _added_ a through= ?

                    if auto_through(old_field) and not auto_through(new_field):

                        yield ("DeleteM2M", {"model": self.old_orm[key], "field": old_field})

                    # Have they _removed_ a through= ?

                    if not auto_through(old_field) and auto_through(new_field):

                        yield ("AddM2M", {"model": self.current_model_from_key(key), "field": new_field})

                ## See if the unique_togethers have changed

                # First, normalise them into lists of sets.

                old_unique_together = eval(old_meta.get("unique_together", "[]"))

                new_unique_together = eval(new_meta.get("unique_together", "[]"))

                if old_unique_together and isinstance(old_unique_together[0], basestring):

                    old_unique_together = [old_unique_together]

                if new_unique_together and isinstance(new_unique_together[0], basestring):

                    new_unique_together = [new_unique_together]

                old_unique_together = map(set, old_unique_together)

                new_unique_together = map(set, new_unique_together)

                # See if any appeared or disappeared

                for item in old_unique_together:

                    if item not in new_unique_together:

                        yield ("DeleteUnique", {

                            "model": self.old_orm[key],

                            "fields": [self.old_orm[key + ":" + x] for x in item],

                        })

                for item in new_unique_together:

                    if item not in old_unique_together:

                        yield ("AddUnique", {

                            "model": self.current_model_from_key(key),

                            "fields": [self.current_field_from_key(key, x) for x in item],

                        })

    @classmethod

    def is_triple(cls, triple):

        "Returns whether the argument is a triple."

        return isinstance(triple, (list, tuple)) and len(triple) == 3 and \

            isinstance(triple[0], (str, unicode)) and \

            isinstance(triple[1], (list, tuple)) and \

            isinstance(triple[2], dict)

    @classmethod

    def different_attributes(cls, old, new):

        """

        Backwards-compat comparison that ignores orm. on the RHS and not the left

        and which knows django.db.models.fields.CharField = models.CharField.

        Has a whole load of tests in tests/autodetection.py.

        """

        # If they're not triples, just do normal comparison

        if not cls.is_triple(old) or not cls.is_triple(new):

            return old != new

        # Expand them out into parts

        old_field, old_pos, old_kwd = old

        new_field, new_pos, new_kwd = new

        # Copy the positional and keyword arguments so we can compare them and pop off things

        old_pos, new_pos = old_pos[:], new_pos[:]

        old_kwd = dict(old_kwd.items())

        new_kwd = dict(new_kwd.items())

        # Remove comparison of the existence of 'unique', that's done elsewhere.

        # TODO: Make this work for custom fields where unique= means something else?

        if "unique" in old_kwd:

            del old_kwd['unique']

        if "unique" in new_kwd:

            del new_kwd['unique']

        # If the first bit is different, check it's not by dj.db.models...

        if old_field != new_field:

            if old_field.startswith("models.") and (new_field.startswith("django.db.models") \

             or new_field.startswith("django.contrib.gis")):

                if old_field.split(".")[-1] != new_field.split(".")[-1]:

                    return True

                else:

                    # Remove those fields from the final comparison

                    old_field = new_field = ""

        # If there's a positional argument in the first, and a 'to' in the second,

        # see if they're actually comparable.

        if (old_pos and "to" in new_kwd) and ("orm" in new_kwd['to'] and "orm" not in old_pos[0]):

            # Do special comparison to fix #153

            try:

                if old_pos[0] != new_kwd['to'].split("'")[1].split(".")[1]:

                    return True

            except IndexError:

                pass # Fall back to next comparison

            # Remove those attrs from the final comparison

            old_pos = old_pos[1:]

            del new_kwd['to']

        return old_field != new_field or old_pos != new_pos or old_kwd != new_kwd

class ManualChanges(BaseChanges):

    """

    Detects changes by reading the command line.

    """

    def __init__(self, migrations, added_models, added_fields, added_indexes):

        self.migrations = migrations

        self.added_models = added_models

        self.added_fields = added_fields

        self.added_indexes = added_indexes

    def suggest_name(self):

        bits = []

        for model_name in self.added_models:

            bits.append('add_model_%s' % model_name)

        for field_name in self.added_fields:

            bits.append('add_field_%s' % field_name)

        for index_name in self.added_indexes:

            bits.append('add_index_%s' % index_name)

        return '_'.join(bits).replace('.', '_')

    def get_changes(self):

        # Get the model defs so we can use them for the yield later

        model_defs = freeze_apps([self.migrations.app_label()])

        # Make the model changes

        for model_name in self.added_models:

            model = models.get_model(self.migrations.app_label(), model_name)

            real_fields, meta, m2m_fields = self.split_model_def(model, model_defs[model_key(model)])

            yield ("AddModel", {

                "model": model,

                "model_def": real_fields,

            })

        # And the field changes

        for field_desc in self.added_fields:

            try:

                model_name, field_name = field_desc.split(".")

            except (TypeError, ValueError):

                raise ValueError("%r is not a valid field description." % field_desc)

            model = models.get_model(self.migrations.app_label(), model_name)

            real_fields, meta, m2m_fields = self.split_model_def(model, model_defs[model_key(model)])

            yield ("AddField", {

                "model": model,

                "field": model._meta.get_field_by_name(field_name)[0],

                "field_def": real_fields[field_name],

            })

        # And the indexes

        for field_desc in self.added_indexes:

            try:

                model_name, field_name = field_desc.split(".")

            except (TypeError, ValueError):

                print "%r is not a valid field description." % field_desc

            model = models.get_model(self.migrations.app_label(), model_name)

            yield ("AddIndex", {

                "model": model,

                "fields": [model._meta.get_field_by_name(field_name)[0]],

            })

class InitialChanges(BaseChanges):

    """

    Creates all models; handles --initial.

    """

    def suggest_name(self):

        return 'initial'

    def __init__(self, migrations):

        self.migrations = migrations

    def get_changes(self):

        # Get the frozen models for this app

        model_defs = freeze_apps([self.migrations.app_label()])

        for model in models.get_models(models.get_app(self.migrations.app_label())):

            # Don't do anything for unmanaged, abstract or proxy models

            if model._meta.abstract or getattr(model._meta, "proxy", False) or not getattr(model._meta, "managed", True):

                continue

            real_fields, meta, m2m_fields = self.split_model_def(model, model_defs[model_key(model)])

            # Firstly, add the main table and fields

            yield ("AddModel", {