django-migrate-sql-deux 1.0.0__py3-none-any.whl

django_migrate_sql/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.0.0'

django_migrate_sql/autodetector.py

@@ -0,0 +1,326 @@
+import django
+from django.conf import settings
+from django.db.migrations.autodetector import MigrationAutodetector as DjangoMigrationAutodetector
+from django.db.migrations.operations import RunSQL
+from django.utils.datastructures import OrderedSet
+if django.VERSION >= (5, 1):
+    from django.db.migrations.autodetector import OperationDependency
+
+from .operations import (AlterSQL, ReverseAlterSQL, CreateSQL, DeleteSQL, AlterSQLState)
+from .graph import SQLStateGraph
+
+
+class SQLBlob(object):
+    pass
+
+# Dummy object used to identify django dependency as the one used by this tool only.
+SQL_BLOB = SQLBlob()
+
+
+def _sql_params(sql):
+    """
+    Identify `sql` as either SQL string or 2-tuple of SQL and params.
+    Same format as supported by Django's RunSQL operation for sql/reverse_sql.
+    """
+    params = None
+    if isinstance(sql, (list, tuple)):
+        elements = len(sql)
+        if elements == 2:
+            sql, params = sql
+        else:
+            raise ValueError("Expected a 2-tuple but got %d" % elements)
+    return sql, params
+
+
+def is_sql_equal(sqls1, sqls2):
+    """
+    Find out equality of two SQL items.
+
+    See https://docs.djangoproject.com/en/1.8/ref/migration-operations/#runsql.
+    Args:
+        sqls1, sqls2: SQL items, have the same format as supported by Django's RunSQL operation.
+    Returns:
+        (bool) `True` if equal, otherwise `False`.
+    """
+    is_seq1 = isinstance(sqls1, (list, tuple))
+    is_seq2 = isinstance(sqls2, (list, tuple))
+
+    if not is_seq1:
+        sqls1 = (sqls1,)
+    if not is_seq2:
+        sqls2 = (sqls2,)
+
+    if len(sqls1) != len(sqls2):
+        return False
+
+    for sql1, sql2 in zip(sqls1, sqls2):
+        sql1, params1 = _sql_params(sql1)
+        sql2, params2 = _sql_params(sql2)
+        if sql1 != sql2 or params1 != params2:
+            return False
+    return True
+
+
+def get_ancestors(node):
+    """Logic extracted from Django <2.2 as this is dropped in later versions."""
+    if '_ancestors' not in node.__dict__:
+        ancestors = []
+        for parent in sorted(node.parents, reverse=True):
+            ancestors += get_ancestors(parent)
+        ancestors.append(node.key)
+        node.__dict__['_ancestors'] = list(OrderedSet(ancestors))
+    return node.__dict__['_ancestors']
+
+
+def get_descendants(node):
+    """Logic extracted from Django <2.2 as this is dropped in later versions."""
+    if '_descendants' not in node.__dict__:
+        descendants = []
+        for child in sorted(node.children, reverse=True):
+            descendants += get_descendants(child)
+        descendants.append(node.key)
+        node.__dict__['_descendants'] = list(OrderedSet(descendants))
+    return node.__dict__['_descendants']
+
+
+class MigrationAutodetector(DjangoMigrationAutodetector):
+    """
+    Substitutes Django's MigrationAutodetector class, injecting SQL migrations logic.
+    """
+    def __init__(self, from_state, to_state, questioner=None, to_sql_graph=None):
+        super(MigrationAutodetector, self).__init__(from_state, to_state, questioner)
+        self.to_sql_graph = to_sql_graph
+        self.from_sql_graph = getattr(self.from_state, 'sql_state', None) or SQLStateGraph()
+        self.from_sql_graph.build_graph()
+        self._sql_operations = []
+
+    def assemble_changes(self, keys, resolve_keys, sql_state):
+        """
+        Accepts keys of SQL items available, sorts them and adds additional dependencies.
+        Uses graph of `sql_state` nodes to build `keys` and `resolve_keys` into sequence that
+        starts with leaves (items that have not dependents) and ends with roots.
+
+        Changes `resolve_keys` argument as dependencies are added to the result.
+
+        Args:
+            keys (list): List of migration keys, that are one of create/delete operations, and
+                dont require respective reverse operations.
+            resolve_keys (list): List of migration keys, that are changing existing items,
+                and may require respective reverse operations.
+            sql_sate (graph.SQLStateGraph): State of SQL items.
+        Returns:
+            (list) Sorted sequence of migration keys, enriched with dependencies.
+        """
+        result_keys = []
+        all_keys = keys | resolve_keys
+        for key in all_keys:
+            node = sql_state.node_map[key]
+            sql_item = sql_state.nodes[key]
+            ancs = get_ancestors(node)[:-1]
+            ancs.reverse()
+            pos = next((i for i, k in enumerate(result_keys) if k in ancs), len(result_keys))
+            result_keys.insert(pos, key)
+
+            if key in resolve_keys and not sql_item.replace:
+                # ancestors() and descendants() include key itself, need to cut it out.
+                descs = reversed(get_descendants(node)[:-1])
+                for desc in descs:
+                    if desc not in all_keys and desc not in result_keys:
+                        result_keys.insert(pos, desc)
+                        # these items added may also need reverse operations.
+                        resolve_keys.add(desc)
+        return result_keys
+
+    def add_sql_operation(self, app_label, sql_name, operation, dependencies):
+        """
+        Add SQL operation and register it to be used as dependency for further
+        sequential operations.
+        """
+        if django.VERSION >= (5, 1):
+            deps = [
+                OperationDependency(
+                    app_label=dp[0],
+                    model_name=SQL_BLOB,
+                    field_name=dp[1],
+                    type=self._sql_operations.get(dp),
+                )
+                for dp in dependencies
+            ]
+        else:
+            deps = [(dp[0], SQL_BLOB, dp[1], self._sql_operations.get(dp)) for dp in dependencies]
+
+        self.add_operation(app_label, operation, dependencies=deps)
+        self._sql_operations[(app_label, sql_name)] = operation
+
+    def _generate_reversed_sql(self, keys, changed_keys):
+        """
+        Generate reversed operations for changes, that require full rollback and creation.
+        """
+        for key in keys:
+            if key not in changed_keys:
+                continue
+            app_label, sql_name = key
+            old_item = self.from_sql_graph.nodes[key]
+            new_item = self.to_sql_graph.nodes[key]
+            if not old_item.reverse_sql or old_item.reverse_sql == RunSQL.noop or new_item.replace:
+                continue
+
+            # migrate backwards
+            operation = ReverseAlterSQL(sql_name, old_item.reverse_sql, reverse_sql=old_item.sql)
+            sql_deps = [n.key for n in self.from_sql_graph.node_map[key].children]
+            sql_deps.append(key)
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def _generate_sql(self, keys, changed_keys):
+        """
+        Generate forward operations for changing/creating SQL items.
+        """
+        for key in reversed(keys):
+            app_label, sql_name = key
+            new_item = self.to_sql_graph.nodes[key]
+            sql_deps = [n.key for n in self.to_sql_graph.node_map[key].parents]
+            reverse_sql = new_item.reverse_sql
+
+            if key in changed_keys:
+                operation_cls = AlterSQL
+                kwargs = {}
+                # in case of replace mode, AlterSQL will hold sql, reverse_sql and
+                # state_reverse_sql, the latter one will be used for building state forward
+                # instead of reverse_sql.
+                if new_item.replace:
+                    kwargs['state_reverse_sql'] = reverse_sql
+                    reverse_sql = self.from_sql_graph.nodes[key].sql
+            else:
+                operation_cls = CreateSQL
+                kwargs = {'dependencies': list(sql_deps)}
+
+            operation = operation_cls(
+                sql_name, new_item.sql, reverse_sql=reverse_sql, **kwargs)
+            sql_deps.append(key)
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def _generate_altered_sql_dependencies(self, dep_changed_keys):
+        """
+        Generate forward operations for changing/creating SQL item dependencies.
+
+        Dependencies are only in-memory and should be reflecting database dependencies, so
+        changing them in SQL config does not alter database. Such actions are persisted in separate
+        type operation - `AlterSQLState`.
+
+        Args:
+            dep_changed_keys (list): Data about keys, that have their dependencies changed.
+                List of tuples (key, removed depndencies, added_dependencies).
+        """
+        for key, removed_deps, added_deps in dep_changed_keys:
+            app_label, sql_name = key
+            operation = AlterSQLState(sql_name, add_dependencies=tuple(added_deps),
+                                      remove_dependencies=tuple(removed_deps))
+            sql_deps = [key]
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def _generate_delete_sql(self, delete_keys):
+        """
+        Generate forward delete operations for SQL items.
+        """
+        for key in delete_keys:
+            app_label, sql_name = key
+            old_node = self.from_sql_graph.nodes[key]
+            operation = DeleteSQL(sql_name, old_node.reverse_sql, reverse_sql=old_node.sql)
+            sql_deps = [n.key for n in self.from_sql_graph.node_map[key].children]
+            sql_deps.append(key)
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def generate_sql_changes(self):
+        """
+        Starting point of this tool, which identifies changes and generates respective
+        operations.
+        """
+        from_keys = set(self.from_sql_graph.nodes.keys())
+        to_keys = set(self.to_sql_graph.nodes.keys())
+        new_keys = to_keys - from_keys
+        delete_keys = from_keys - to_keys
+        changed_keys = set()
+        dep_changed_keys = []
+
+        for key in from_keys & to_keys:
+            old_node = self.from_sql_graph.nodes[key]
+            new_node = self.to_sql_graph.nodes[key]
+
+            # identify SQL changes -- these will alter database.
+            if not is_sql_equal(old_node.sql, new_node.sql):
+                changed_keys.add(key)
+
+            # identify dependencies change
+            old_deps = self.from_sql_graph.dependencies[key]
+            new_deps = self.to_sql_graph.dependencies[key]
+            removed_deps = old_deps - new_deps
+            added_deps = new_deps - old_deps
+            if removed_deps or added_deps:
+                dep_changed_keys.append((key, removed_deps, added_deps))
+
+        # we do basic sort here and inject dependency keys here.
+        # operations built using these keys will properly set operation dependencies which will
+        # enforce django to build/keep a correct order of operations (stable_topological_sort).
+        keys = self.assemble_changes(new_keys, changed_keys, self.to_sql_graph)
+        delete_keys = self.assemble_changes(delete_keys, set(), self.from_sql_graph)
+
+        self._sql_operations = {}
+        self._generate_reversed_sql(keys, changed_keys)
+        self._generate_sql(keys, changed_keys)
+        self._generate_delete_sql(delete_keys)
+        self._generate_altered_sql_dependencies(dep_changed_keys)
+
+    def check_dependency(self, operation, dependency):
+        """
+        Enhances default behavior of method by checking dependency for matching operation.
+        """
+        if django.VERSION >= (5, 1):
+            # dependency is a named tuple
+            if isinstance(dependency.model_name, SQLBlob):
+                # NOTE: we follow the sort order created by `assemble_changes` so we build a fixed chain
+                # of operations. thus we should match exact operation here.
+                return dependency.type == operation
+        else:
+            # dependency is a tuple
+            if isinstance(dependency[1], SQLBlob):
+                # NOTE: we follow the sort order created by `assemble_changes` so we build a fixed chain
+                # of operations. thus we should match exact operation here.
+                return dependency[3] == operation
+        return super(MigrationAutodetector, self).check_dependency(operation, dependency)
+
+    def generate_altered_fields(self):
+        """
+        Injecting point. This is quite awkward, and i'm looking forward Django for having the logic
+        divided into smaller methods/functions for easier enhancement and substitution.
+        So far we're doing all the SQL magic in this method.
+        """
+        result = super(MigrationAutodetector, self).generate_altered_fields()
+        self.generate_sql_changes()
+        return result
+
+    @staticmethod
+    def _resolve_dependency(dependency):
+        """
+        Return the resolved dependency and a boolean denoting whether or not
+        it was swappable.
+        """
+        if dependency[0] != "__setting__":
+            return dependency, False
+        resolved_app_label, resolved_object_name = getattr(
+            settings, dependency[1]
+        ).split(".")
+        if django.VERSION >= (5, 1):
+            return (
+                OperationDependency(
+                    resolved_app_label,
+                    resolved_object_name.lower(),
+                    dependency[2],
+                    dependency[3],
+                ),
+                True,
+            )
+        else:
+            return (
+                (resolved_app_label, resolved_object_name.lower()) + dependency[2:],
+                True
+            )

django_migrate_sql/config.py

@@ -0,0 +1,25 @@
+class SQLItem(object):
+    """
+    Represents any SQL entity (unit), for example function, type, index or trigger.
+    """
+    def __init__(self, name, sql, reverse_sql=None, dependencies=None, replace=False):
+        """
+        Args:
+            name (str): Name of the SQL item. Should be unique among other items in the current
+                application. It is the name that other items can refer to.
+            sql (str/tuple): Forward SQL that creates entity.
+            drop_sql (str/tuple, optional): Backward SQL that destroyes entity. (DROPs).
+            dependencies (list, optional): Collection of item keys, that the current one depends on.
+                Each element is a tuple of two: (app, item_name). Order does not matter.
+            replace (bool, optional): If `True`, further migrations will not drop previous version
+                of item before creating, assuming that a forward SQL replaces. For example Postgre's
+                `create or replace function` which does not require dropping it previously.
+                If `False` then each changed item will get two operations: dropping previous version
+                and creating new one.
+                Default = `False`.
+        """
+        self.name = name
+        self.sql = sql
+        self.reverse_sql = reverse_sql
+        self.dependencies = dependencies or []
+        self.replace = replace

django_migrate_sql/graph.py

@@ -0,0 +1,119 @@
+from collections import defaultdict
+from importlib import import_module
+
+from django.db.migrations.graph import Node, NodeNotFoundError, CircularDependencyError
+from django.conf import settings
+from django.apps import apps
+
+SQL_CONFIG_MODULE = settings.__dict__.get('SQL_CONFIG_MODULE', 'sql_config')
+
+
+class SQLStateGraph(object):
+    """
+    Represents graph assembled by SQL items as nodes and parent-child relations as arcs.
+    """
+    def __init__(self):
+        self.nodes = {}
+        self.node_map = {}
+        self.dependencies = defaultdict(set)
+
+    def remove_node(self, key):
+        # XXX: Workaround for Issue #2
+        # Silences state aggregation problem in `migrate` command.
+        if key in self.nodes and key in self.node_map:
+            del self.nodes[key]
+            del self.node_map[key]
+
+    def add_node(self, key, sql_item):
+        node = Node(key)
+        self.node_map[key] = node
+        self.nodes[key] = sql_item
+
+    def add_lazy_dependency(self, child, parent):
+        """
+        Add dependency to be resolved and applied later.
+        """
+        self.dependencies[child].add(parent)
+
+    def remove_lazy_dependency(self, child, parent):
+        """
+        Add dependency to be resolved and applied later.
+        """
+        self.dependencies[child].remove(parent)
+
+    def remove_lazy_for_child(self, child):
+        """
+        Remove dependency to be resolved and applied later.
+        """
+        if child in self.dependencies:
+            del self.dependencies[child]
+
+    def build_graph(self):
+        """
+        Read lazy dependency list and build graph.
+        """
+        for child, parents in self.dependencies.items():
+            if child not in self.nodes:
+                raise NodeNotFoundError(
+                    "App %s SQL item dependencies reference nonexistent child node %r" % (
+                        child[0], child),
+                    child
+                )
+            for parent in parents:
+                if parent not in self.nodes:
+                    raise NodeNotFoundError(
+                        "App %s SQL item dependencies reference nonexistent parent node %r" % (
+                            child[0], parent),
+                        parent
+                    )
+                self.node_map[child].add_parent(self.node_map[parent])
+                self.node_map[parent].add_child(self.node_map[child])
+
+        for node in self.nodes:
+            self.ensure_not_cyclic(node,
+                                   lambda x: (parent.key for parent in self.node_map[x].parents))
+
+    def ensure_not_cyclic(self, start, get_children):
+        # Algo from GvR:
+        # http://neopythonic.blogspot.co.uk/2009/01/detecting-cycles-in-directed-graph.html
+        todo = set(self.nodes)
+        while todo:
+            node = todo.pop()
+            stack = [node]
+            while stack:
+                top = stack[-1]
+                for node in get_children(top):
+                    if node in stack:
+                        cycle = stack[stack.index(node):]
+                        raise CircularDependencyError(", ".join("%s.%s" % n for n in cycle))
+                    if node in todo:
+                        stack.append(node)
+                        todo.remove(node)
+                        break
+                else:
+                    node = stack.pop()
+
+
+def build_current_graph():
+    """
+    Read current state of SQL items from the current project state.
+
+    Returns:
+        (SQLStateGraph) Current project state graph.
+    """
+    graph = SQLStateGraph()
+    for app_name, config in apps.app_configs.items():
+        try:
+            module = import_module(
+                '.'.join((config.module.__name__, SQL_CONFIG_MODULE)))
+            sql_items = module.sql_items
+        except (ImportError, AttributeError):
+            continue
+        for sql_item in sql_items:
+            graph.add_node((app_name, sql_item.name), sql_item)
+
+            for dep in sql_item.dependencies:
+                graph.add_lazy_dependency((app_name, sql_item.name), dep)
+
+    graph.build_graph()
+    return graph

django_migrate_sql/management/commands/makemigrations.py

@@ -0,0 +1,143 @@
+"""
+Replaces built-in Django command and forces it generate SQL item modification operations
+into regular Django migrations.
+"""
+
+import sys
+
+import django
+from django.core.management.commands.makemigrations import Command as MakeMigrationsCommand
+from django.db.migrations.loader import MigrationLoader
+from django.db.migrations import Migration
+from django.core.management.base import CommandError, no_translations
+from django.db.migrations.questioner import InteractiveMigrationQuestioner
+from django.apps import apps
+from django.db.migrations.state import ProjectState
+
+from ...autodetector import MigrationAutodetector
+from ...graph import build_current_graph
+
+
+class Command(MakeMigrationsCommand):
+
+    @no_translations
+    def handle(self, *app_labels, **options):
+        if django.VERSION >= (4, 1):
+            self.written_files = []
+        self.verbosity = options.get('verbosity')
+        self.interactive = options.get('interactive')
+        self.dry_run = options.get('dry_run', False)
+        self.merge = options.get('merge', False)
+        self.empty = options.get('empty', False)
+        self.migration_name = options.get('name', None)
+        self.exit_code = options.get('exit_code', False)
+        self.include_header = options.get('include_header', True)
+        check_changes = options.get('check_changes', False)
+        if django.VERSION >= (4, 1):
+            self.scriptable = options["scriptable"]
+            # If logs and prompts are diverted to stderr, remove the ERROR style.
+            if self.scriptable:
+                self.stderr.style_func = None
+
+        # Make sure the app they asked for exists
+        app_labels = set(app_labels)
+        bad_app_labels = set()
+        for app_label in app_labels:
+            try:
+                apps.get_app_config(app_label)
+            except LookupError:
+                bad_app_labels.add(app_label)
+        if bad_app_labels:
+            for app_label in bad_app_labels:
+                self.stderr.write("App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label)
+            sys.exit(2)
+
+        # Load the current graph state. Pass in None for the connection so
+        # the loader doesn't try to resolve replaced migrations from DB.
+        loader = MigrationLoader(None, ignore_no_migrations=True)
+
+        # Before anything else, see if there's conflicting apps and drop out
+        # hard if there are any and they don't want to merge
+        conflicts = loader.detect_conflicts()
+
+        # If app_labels is specified, filter out conflicting migrations for unspecified apps
+        if app_labels:
+            conflicts = {
+                app_label: conflict for app_label, conflict in conflicts.items()
+                if app_label in app_labels
+            }
+
+        if conflicts and not self.merge:
+            name_str = "; ".join(
+                "%s in %s" % (", ".join(names), app)
+                for app, names in conflicts.items()
+            )
+            raise CommandError(
+                "Conflicting migrations detected (%s).\nTo fix them run "
+                "'python manage.py makemigrations --merge'" % name_str
+            )
+
+        # If they want to merge and there's nothing to merge, then politely exit
+        if self.merge and not conflicts:
+            self.stdout.write("No conflicts detected to merge.")
+            return
+
+        # If they want to merge and there is something to merge, then
+        # divert into the merge code
+        if self.merge and conflicts:
+            return self.handle_merge(loader, conflicts)
+
+        state = loader.project_state()
+
+        # NOTE: customization. Passing graph to autodetector.
+        sql_graph = build_current_graph()
+
+        # Set up autodetector
+        autodetector = MigrationAutodetector(
+            state,
+            ProjectState.from_apps(apps),
+            InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run),
+            sql_graph,
+        )
+
+        # If they want to make an empty migration, make one for each app
+        if self.empty:
+            if not app_labels:
+                raise CommandError("You must supply at least one app label when using --empty.")
+            # Make a fake changes() result we can pass to arrange_for_graph
+            changes = {
+                app: [Migration("custom", app)]
+                for app in app_labels
+            }
+            changes = autodetector.arrange_for_graph(
+                changes=changes,
+                graph=loader.graph,
+                migration_name=self.migration_name,
+            )
+            self.write_migration_files(changes)
+            return
+
+        # Detect changes
+        changes = autodetector.changes(
+            graph=loader.graph,
+            trim_to_apps=app_labels or None,
+            convert_apps=app_labels or None,
+            migration_name=self.migration_name,
+        )
+
+        if not changes:
+            # No changes? Tell them.
+            if self.verbosity >= 1:
+                if len(app_labels) == 1:
+                    self.stdout.write("No changes detected in app '%s'" % app_labels.pop())
+                elif len(app_labels) > 1:
+                    self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels)))
+                else:
+                    self.stdout.write("No changes detected")
+
+            if self.exit_code:
+                sys.exit(1)
+        else:
+            self.write_migration_files(changes)
+            if check_changes:
+                sys.exit(1)

django_migrate_sql/operations.py

@@ -0,0 +1,221 @@
+import django
+from django.db.migrations.operations import RunSQL
+from django.db.migrations.operations.base import Operation
+if django.VERSION >= (5, 1):
+    from django.db.migrations.operations.base import OperationCategory
+
+from .graph import SQLStateGraph
+from .config import SQLItem
+
+
+class MigrateSQLMixin(object):
+    def get_sql_state(self, state):
+        """
+        Get SQLStateGraph from state.
+        """
+        if not hasattr(state, 'sql_state'):
+            setattr(state, 'sql_state', SQLStateGraph())
+        return state.sql_state
+
+
+class AlterSQLState(MigrateSQLMixin, Operation):
+    """
+    Alters in-memory state of SQL item.
+    This operation is generated separately from others since it does not affect database.
+    """
+
+    if django.VERSION >= (5, 1):
+        category = OperationCategory.PYTHON
+
+    def describe(self):
+        return 'Alter SQL state "{name}"'.format(name=self.name)
+
+    def deconstruct(self):
+        kwargs = {
+            'name': self.name,
+        }
+        if self.add_dependencies:
+            kwargs['add_dependencies'] = self.add_dependencies
+        if self.remove_dependencies:
+            kwargs['remove_dependencies'] = self.remove_dependencies
+        return (self.__class__.__name__, [], kwargs)
+
+    def state_forwards(self, app_label, state):
+        sql_state = self.get_sql_state(state)
+        key = (app_label, self.name)
+
+        if key not in sql_state.nodes:
+            # XXX: dummy for `migrate` command, that does not preserve state object.
+            # Should fail with error when fixed.
+            return
+
+        sql_item = sql_state.nodes[key]
+
+        for dep in self.add_dependencies:
+            # we are also adding relations to aggregated SQLItem, but only to restore
+            # original items. Still using graph for advanced node/arc manipulations.
+
+            # XXX: dummy `if` for `migrate` command, that does not preserve state object.
+            # Fail with error when fixed
+            if dep in sql_item.dependencies:
+                sql_item.dependencies.remove(dep)
+            sql_state.add_lazy_dependency(key, dep)
+
+        for dep in self.remove_dependencies:
+            sql_item.dependencies.append(dep)
+            sql_state.remove_lazy_dependency(key, dep)
+
+    def database_forwards(self, app_label, schema_editor, from_state, to_state):
+        pass
+
+    def database_backwards(self, app_label, schema_editor, from_state, to_state):
+        pass
+
+    @property
+    def reversible(self):
+        return True
+
+    def __init__(self, name, add_dependencies=None, remove_dependencies=None):
+        """
+        Args:
+            name (str): Name of SQL item in current application to alter state for.
+            add_dependencies (list):
+                Unordered list of dependencies to add to state.
+            remove_dependencies (list):
+                Unordered list of dependencies to remove from state.
+        """
+        self.name = name
+        self.add_dependencies = add_dependencies or ()
+        self.remove_dependencies = remove_dependencies or ()
+
+
+class BaseAlterSQL(MigrateSQLMixin, RunSQL):
+    """
+    Base class for operations that alter database.
+    """
+
+    if django.VERSION >= (5, 1):
+        category = OperationCategory.SQL
+
+    def __init__(self, name, sql, reverse_sql=None, state_operations=None, hints=None):
+        super(BaseAlterSQL, self).__init__(sql, reverse_sql=reverse_sql,
+                                           state_operations=state_operations, hints=hints)
+        self.name = name
+
+    def deconstruct(self):
+        name, args, kwargs = super(BaseAlterSQL, self).deconstruct()
+        kwargs['name'] = self.name
+        return (name, args, kwargs)
+
+
+class ReverseAlterSQL(BaseAlterSQL):
+
+    if django.VERSION >= (5, 1):
+        category = OperationCategory.ALTERATION
+
+    def describe(self):
+        return 'Reverse alter SQL "{name}"'.format(name=self.name)
+
+
+class AlterSQL(BaseAlterSQL):
+    """
+    Updates SQL item with a new version.
+    """
+
+    if django.VERSION >= (5, 1):
+        category = OperationCategory.ALTERATION
+
+    def __init__(self, name, sql, reverse_sql=None, state_operations=None, hints=None,
+                 state_reverse_sql=None):
+        """
+        Args:
+            name (str): Name of SQL item in current application to alter state for.
+            sql (str/list): Forward SQL for item creation.
+            reverse_sql (str/list): Backward SQL for reversing create operation.
+            state_reverse_sql (str/list): Backward SQL used to alter state of backward SQL
+                *instead* of `reverse_sql`. Used for operations generated for items with
+                `replace` = `True`.
+        """
+        super(AlterSQL, self).__init__(name, sql, reverse_sql=reverse_sql,
+                                       state_operations=state_operations, hints=hints)
+        self.state_reverse_sql = state_reverse_sql
+
+    def deconstruct(self):
+        name, args, kwargs = super(AlterSQL, self).deconstruct()
+        kwargs['name'] = self.name
+        if self.state_reverse_sql:
+            kwargs['state_reverse_sql'] = self.state_reverse_sql
+        return (name, args, kwargs)
+
+    def describe(self):
+        return 'Alter SQL "{name}"'.format(name=self.name)
+
+    def state_forwards(self, app_label, state):
+        super(AlterSQL, self).state_forwards(app_label, state)
+        sql_state = self.get_sql_state(state)
+        key = (app_label, self.name)
+
+        if key not in sql_state.nodes:
+            # XXX: dummy for `migrate` command, that does not preserve state object.
+            # Fail with error when fixed
+            return
+
+        sql_item = sql_state.nodes[key]
+        sql_item.sql = self.sql
+        sql_item.reverse_sql = self.state_reverse_sql or self.reverse_sql
+
+
+class CreateSQL(BaseAlterSQL):
+    """
+    Creates new SQL item in database.
+    """
+
+    if django.VERSION >= (5, 1):
+        category = OperationCategory.ADDITION
+
+    def describe(self):
+        return 'Create SQL "{name}"'.format(name=self.name)
+
+    def deconstruct(self):
+        name, args, kwargs = super(CreateSQL, self).deconstruct()
+        kwargs['name'] = self.name
+        if self.dependencies:
+            kwargs['dependencies'] = self.dependencies
+        return (name, args, kwargs)
+
+    def __init__(self, name, sql, reverse_sql=None, state_operations=None, hints=None,
+                 dependencies=None):
+        super(CreateSQL, self).__init__(name, sql, reverse_sql=reverse_sql,
+                                        state_operations=state_operations, hints=hints)
+        self.dependencies = dependencies or ()
+
+    def state_forwards(self, app_label, state):
+        super(CreateSQL, self).state_forwards(app_label, state)
+        sql_state = self.get_sql_state(state)
+
+        sql_state.add_node(
+            (app_label, self.name),
+            SQLItem(self.name, self.sql, self.reverse_sql, list(self.dependencies)),
+        )
+
+        for dep in self.dependencies:
+            sql_state.add_lazy_dependency((app_label, self.name), dep)
+
+
+class DeleteSQL(BaseAlterSQL):
+    """
+    Deltes SQL item from database.
+    """
+
+    if django.VERSION >= (5, 1):
+        category = OperationCategory.REMOVAL
+
+    def describe(self):
+        return 'Delete SQL "{name}"'.format(name=self.name)
+
+    def state_forwards(self, app_label, state):
+        super(DeleteSQL, self).state_forwards(app_label, state)
+        sql_state = self.get_sql_state(state)
+
+        sql_state.remove_node((app_label, self.name))
+        sql_state.remove_lazy_for_child((app_label, self.name))

django_migrate_sql_deux-1.0.0.dist-info/METADATA

@@ -0,0 +1,306 @@
+Metadata-Version: 2.4
+Name: django-migrate-sql-deux
+Version: 1.0.0
+Summary: Django Migrations for raw SQL
+Author-email: Bogdan Klichuk <klichukb@gmail.com>, Bruno Alla <oss@browniebroke.com>
+License: BSD
+Project-URL: Bug Tracker, https://github.com/browniebroke/django-migrate-sql-deux/issues
+Project-URL: Changelog, https://github.com/browniebroke/django-migrate-sql-deux/blob/main/CHANGELOG.md
+Project-URL: repository, https://github.com/browniebroke/django-migrate-sql-deux
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Dynamic: license-file
+
+# django-migrate-sql-deux
+
+<p align="center">
+  <a href="https://github.com/browniebroke/django-migrate-sql-deux/actions/workflows/ci.yml?query=branch%3Amain">
+    <img src="https://img.shields.io/github/actions/workflow/status/browniebroke/django-migrate-sql-deux/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
+  </a>
+  <a href="https://codecov.io/gh/browniebroke/django-migrate-sql-deux">
+    <img src="https://img.shields.io/codecov/c/github/browniebroke/django-migrate-sql-deux.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
+  </a>
+</p>
+<p align="center">
+  <a href="https://github.com/astral-sh/uv">
+    <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json" alt="uv">
+  </a>
+  <a href="https://github.com/astral-sh/ruff">
+    <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff">
+  </a>
+  <a href="https://github.com/pre-commit/pre-commit">
+    <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
+  </a>
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/django-migrate-sql-deux/">
+    <img src="https://img.shields.io/pypi/v/django-migrate-sql-deux.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/django-migrate-sql-deux.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/django-migrate-sql-deux.svg?style=flat-square" alt="License">
+</p>
+
+---
+
+**Source Code**: <a href="https://github.com/browniebroke/django-migrate-sql-deux" target="_blank">https://github.com/browniebroke/django-migrate-sql-deux </a>
+
+---
+
+Django Migrations support for raw SQL.
+
+> [!NOTE]
+> This package is a fork of the `django-migrate-sql` package, originally published by Bogdan Klichuk. This package appears unmaintained, so we decided to start a fork as we depended on it. Most of the code is from the original author.
+
+## About
+
+This tool implements mechanism for managing changes to custom SQL entities (functions, types, indices, triggers) using built-in migration mechanism. Technically creates a sophistication layer on top of the
+`RunSQL` Django operation.
+
+## What it does
+
+- Makes maintaining your SQL functions, custom composite types, indices and triggers easier.
+- Structures SQL into configuration of **SQL items**, that are
+  identified by names and divided among apps, just like models.
+- Automatically gathers and persists changes of your custom SQL into
+  migrations using `makemigrations`.
+- Properly executes backwards/forwards keeping integrity of database.
+- Create -> Drop -> Recreate approach for changes to items that do not
+  support altering and require dropping and recreating.
+- Dependencies system for SQL items, which solves the problem of
+  updating items, that rely on others (for example custom
+  types/functions that use other custom types), and require dropping all
+  dependency tree previously with further recreation.
+
+## What it does not
+
+- Does not parse SQL nor validate queries during `makemigrations` or
+  `migrate` because is database-agnostic. For this same reason setting
+  up proper dependencies is user's responsibility.
+- Does not create `ALTER` queries for items that support this, for
+  example `ALTER TYPE` in PostgreSQL, because is database-agnostic. In
+  case your tools allow rolling all the changes through `ALTER` queries,
+  you can consider not using this app **or** restructure migrations
+  manually after creation by nesting generated operations into
+  `` `state_operations `` of [`RunSQL`](https://docs.djangoproject.com/en/1.8/ref/migration-operations/#runsql)
+  that does `ALTER`.
+- (**TODO**)During `migrate` does not restore full state of items for
+  analysis, thus does not notify about existing changes to schema that
+  are not migrated **nor** does not recognize circular dependencies
+  during migration execution.
+
+## Installation
+
+Install from PyPi:
+
+```shell
+pip install django-migrate-sql-deux
+```
+
+Add `django_migrate_sql` to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    'django_migrate_sql',
+]
+```
+
+App defines a custom `makemigrations` command, that inherits from
+Django's core one, so in order `django_migrate_sql` app to kick in put it
+after any other apps that redefine `makemigrations` command too.
+
+## Usage
+
+1)  Create `sql_config.py` module to root of a target app you want to
+    manage custom SQL for.
+2)  Define SQL items in it (`sql_items`), for example:
+
+```python
+# PostgreSQL example.
+# Let's define a simple function and let `django_migrate_sql` manage its changes.
+
+from django_migrate_sql.config import SQLItem
+
+sql_items = [
+    SQLItem(
+        'make_sum',   # name of the item
+        'create or replace function make_sum(a int, b int) returns int as $$ '
+        'begin return a + b; end; '
+        '$$ language plpgsql;',  # forward sql
+        reverse_sql='drop function make_sum(int, int);',  # sql for removal
+    ),
+]
+```
+
+3)  Create migration `python manage.py makemigrations`:
+
+        Migrations for 'app_name':
+          0002_auto_xxxx.py:
+        - Create SQL "make_sum"
+
+You can take a look at content this generated:
+
+```python
+from django.db import migrations, models
+import django_migrate_sql.operations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('app_name', '0001_initial'),
+    ]
+    operations = [
+        django_migrate_sql.operations.CreateSQL(
+            name='make_sum',
+            sql='create or replace function make_sum(a int, b int) returns int as $$ begin return a + b; end; $$ language plpgsql;',
+            reverse_sql='drop function make_sum(int, int);',
+        ),
+    ]
+```
+
+4)  Execute migration `python manage.py migrate`:
+
+        Operations to perform:
+          Apply all migrations: app_name
+        Running migrations:
+          Rendering model states... DONE
+          Applying app_name.0002_xxxx... OK
+
+Check result in `python manage.py dbshell`:
+
+    db_name=# select make_sum(12, 15);
+     make_sum
+    ----------
+           27
+    (1 row)
+
+Now, say, you want to change the function implementation so that it
+takes a custom type as argument:
+
+5)  Edit your `sql_config.py`:
+
+```python
+# PostgreSQL example #2.
+# Function and custom type.
+
+from django_migrate_sql.config import SQLItem
+
+sql_items = [
+    SQLItem(
+        'make_sum',  # name of the item
+        'create or replace function make_sum(a mynum, b mynum) returns mynum as $$ '
+        'begin return (a.num + b.num, 'result')::mynum; end; '
+        '$$ language plpgsql;',  # forward sql
+        reverse_sql='drop function make_sum(mynum, mynum);',  # sql for removal
+        # depends on `mynum` since takes it as argument. we won't be able to drop function
+        # without dropping `mynum` first.
+        dependencies=[('app_name', 'mynum')],
+    ),
+    SQLItem(
+        'mynum'   # name of the item
+        'create type mynum as (num int, name varchar(20));',  # forward sql
+        reverse_sql='drop type mynum;',  # sql for removal
+    ),
+]
+```
+
+6)  Generate migration `python manage.py makemigrations`:
+
+```
+Migrations for 'app_name':
+  0003_xxxx:
+    - Reverse alter SQL "make_sum"
+    - Create SQL "mynum"
+    - Alter SQL "make_sum"
+    - Alter SQL state "make_sum"
+```
+
+You can take a look at the content this generated:
+
+```python
+from django.db import migrations, models
+import django_migrate_sql.operations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('app_name', '0002_xxxx'),
+    ]
+    operations = [
+        django_migrate_sql.operations.ReverseAlterSQL(
+            name='make_sum',
+            sql='drop function make_sum(int, int);',
+            reverse_sql='create or replace function make_sum(a int, b int) returns int as $$ begin return a + b; end; $$ language plpgsql;',
+        ),
+        django_migrate_sql.operations.CreateSQL(
+            name='mynum',
+            sql='create type mynum as (num int, name varchar(20));',
+            reverse_sql='drop type mynum;',
+        ),
+        django_migrate_sql.operations.AlterSQL(
+            name='make_sum',
+            sql='create or replace function make_sum(a mynum, b mynum) returns mynum as $$ begin return (a.num + b.num, \'result\')::mynum; end; $$ language plpgsql;',
+            reverse_sql='drop function make_sum(mynum, mynum);',
+        ),
+        django_migrate_sql.operations.AlterSQLState(
+            name='make_sum',
+            add_dependencies=[('app_name', 'mynum')],
+        ),
+    ]
+```
+
+**NOTE:** Previous function is completely dropped before creation
+because definition of it changed. `CREATE OR REPLACE` would create
+another version of it, so `DROP` makes it clean.
+
+**If you put `replace=True` as kwarg to an `SQLItem`
+definition, it will NOT drop + create it, but just rerun forward SQL,
+which is `CREATE OR REPLACE` in this example.**
+
+7)  Execute migration `python manage.py migrate`:
+
+
+```
+Operations to perform:
+  Apply all migrations: app_name
+Running migrations:
+  Rendering model states... DONE
+  Applying brands.0003_xxxx... OK
+```
+
+Check results:
+
+```
+db_name=# select make_sum((5, 'a')::mynum, (3, 'b')::mynum);
+  make_sum
+------------
+ (8,result)
+(1 row)
+
+db_name=# select make_sum(12, 15);
+ERROR:  function make_sum(integer, integer) does not exist
+LINE 1: select make_sum(12, 15);
+               ^
+HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+```
+
+For more examples see `tests`.
+
+Feel free to [open new issues](https://github.com/browniebroke/django-migrate-sql-deux/issues).

django_migrate_sql_deux-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+django_migrate_sql/__init__.py,sha256=RsZjRjMprNcDm97wqRRSk6rTLgTX8N0GyicZyZ8OsBQ,22
+django_migrate_sql/autodetector.py,sha256=e_y_xFtc1SKk34dJuuQ8a0NfaGjhsgdmuD9xrflbUUQ,13501
+django_migrate_sql/config.py,sha256=uYms22MPVPt3obvb9-a7TvzFgZrSK1gR4KDMGZuQlfw,1391
+django_migrate_sql/graph.py,sha256=MWKiZhzuWF4sCMV3elQ8kqV2yljL4PSHHykNV-YZHOo,4111
+django_migrate_sql/operations.py,sha256=8j3FO4xO9i2KXQp3wag82crTVEl7W4Wh_gQMqOsrXKE,7577
+django_migrate_sql/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_migrate_sql/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_migrate_sql/management/commands/makemigrations.py,sha256=EY3m265PDgx4MKz_sx8gczqd_24Q9MobgjjoD5l_ngI,5535
+django_migrate_sql_deux-1.0.0.dist-info/licenses/LICENSE,sha256=AMfBy7--KzNJGEN6xLEy_-kdwvQP70Ck5y7jLGYmPrs,754
+django_migrate_sql_deux-1.0.0.dist-info/METADATA,sha256=F84DGVO25FRWnRBzOVWtIVr1cd7b5HRDCuuiWVVFWTY,11064
+django_migrate_sql_deux-1.0.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+django_migrate_sql_deux-1.0.0.dist-info/top_level.txt,sha256=At0os64aXXqAwg_WvAa6d9BIoiYXjhHeC84IaUVre3Q,19
+django_migrate_sql_deux-1.0.0.dist-info/RECORD,,

django_migrate_sql_deux-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_migrate_sql_deux-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2016, Bogdan Klichuk <klichukb@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

django_migrate_sql_deux-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+django_migrate_sql