from os import path
+import sys
-__version__ = "1.0.6"
-
-package_dir = path.abspath(path.dirname(__file__))
-
-
-from . import op # noqa
from . import context # noqa
-
-import sys
+from . import op # noqa
from .runtime import environment
from .runtime import migration
+__version__ = "1.0.6"
+
+package_dir = path.abspath(path.dirname(__file__))
+
sys.modules["alembic.migration"] = migration
sys.modules["alembic.environment"] = environment
-from .api import ( # noqa
- compare_metadata,
- _render_migration_diffs,
- produce_migrations,
- render_python_code,
- RevisionContext,
-)
-from .compare import _produce_net_changes, comparators # noqa
-from .render import render_op_text, renderers # noqa
+from .api import _render_migration_diffs # noqa
+from .api import compare_metadata # noqa
+from .api import produce_migrations # noqa
+from .api import render_python_code # noqa
+from .api import RevisionContext # noqa
+from .compare import _produce_net_changes # noqa
+from .compare import comparators # noqa
+from .render import render_op_text # noqa
+from .render import renderers # noqa
from .rewriter import Rewriter # noqa
"""Provide the 'autogenerate' feature which can produce migration operations
automatically."""
-from ..operations import ops
-from . import render
+import contextlib
+
+from sqlalchemy.engine.reflection import Inspector
+
from . import compare
+from . import render
from .. import util
-from sqlalchemy.engine.reflection import Inspector
-import contextlib
+from ..operations import ops
def compare_metadata(context, metadata):
The directives are to be rendered into the ``${imports}`` section
of a script template. The set is normally empty and can be modified
- within hooks such as the :paramref:`.EnvironmentContext.configure.render_item`
- hook.
+ within hooks such as the
+ :paramref:`.EnvironmentContext.configure.render_item` hook.
.. versionadded:: 0.8.3
if include_symbol:
def include_symbol_filter(
- object, name, type_, reflected, compare_to
+ object_, name, type_, reflected, compare_to
):
if type_ == "table":
- return include_symbol(name, object.schema)
+ return include_symbol(name, object_.schema)
else:
return True
-from sqlalchemy import schema as sa_schema, types as sqltypes
-from sqlalchemy.engine.reflection import Inspector
-from sqlalchemy import event
-from ..operations import ops
+import contextlib
import logging
+import re
+
+from sqlalchemy import event
+from sqlalchemy import schema as sa_schema
+from sqlalchemy import types as sqltypes
+from sqlalchemy.engine.reflection import Inspector
+from sqlalchemy.util import OrderedSet
+
+from alembic.ddl.base import _fk_spec
+from .render import _user_defined_render
from .. import util
+from ..operations import ops
from ..util import compat
from ..util import sqla_compat
-from sqlalchemy.util import OrderedSet
-import re
-from .render import _user_defined_render
-import contextlib
-from alembic.ddl.base import _fk_spec
log = logging.getLogger(__name__)
event.listen(
t,
"column_reflect",
- autogen_context.migration_context.impl._compat_autogen_column_reflect(
- inspector
- ),
+ # fmt: off
+ autogen_context.migration_context.impl.
+ _compat_autogen_column_reflect
+ (inspector),
+ # fmt: on
)
inspector.reflecttable(t, None)
if autogen_context.run_filters(t, tname, "table", True, None):
event.listen(
t,
"column_reflect",
- autogen_context.migration_context.impl._compat_autogen_column_reflect(
- inspector
- ),
+ # fmt: off
+ autogen_context.migration_context.impl.
+ _compat_autogen_column_reflect(inspector),
+ # fmt: on
)
inspector.reflecttable(t, None)
conn_column_info[(s, tname)] = t
-from sqlalchemy import schema as sa_schema, types as sqltypes, sql
+import re
+
+from mako.pygen import PythonPrinter
+from sqlalchemy import schema as sa_schema
+from sqlalchemy import sql
+from sqlalchemy import types as sqltypes
+
+from .. import util
from ..operations import ops
from ..util import compat
from ..util import sqla_compat
-import re
from ..util.compat import string_types
-from .. import util
-from mako.pygen import PythonPrinter
from ..util.compat import StringIO
import os
-from .script import ScriptDirectory
-from .runtime.environment import EnvironmentContext
-from . import util
from . import autogenerate as autogen
+from . import util
+from .runtime.environment import EnvironmentContext
+from .script import ScriptDirectory
def list_templates(config):
``-m`` option to ``alembic revision``.
:param autogenerate: whether or not to autogenerate the script from
- the database; this is the ``--autogenerate`` option to ``alembic revision``.
+ the database; this is the ``--autogenerate`` option to
+ ``alembic revision``.
:param sql: whether to dump the script out as a SQL string; when specified,
the script is dumped to stdout. This is the ``--sql`` option to
from argparse import ArgumentParser
-from .util.compat import SafeConfigParser
import inspect
import os
import sys
from . import command
-from . import util
from . import package_dir
+from . import util
from .util import compat
+from .util.compat import SafeConfigParser
class Config(object):
-from . import postgresql, mysql, sqlite, mssql, oracle # pragma: no cover
-from .impl import DefaultImpl # pragma: no cover
+from . import mssql # noqa
+from . import mysql # noqa
+from . import oracle # noqa
+from . import postgresql # noqa
+from . import sqlite # noqa
+from .impl import DefaultImpl # noqa
import functools
-from sqlalchemy.ext.compiler import compiles
-from sqlalchemy.schema import DDLElement, Column
from sqlalchemy import Integer
from sqlalchemy import types as sqltypes
+from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import DDLElement
+
from .. import util
+from ..util.sqla_compat import _columns_for_constraint # noqa
+from ..util.sqla_compat import _find_columns # noqa
+from ..util.sqla_compat import _fk_spec # noqa
+from ..util.sqla_compat import _is_type_bound # noqa
+from ..util.sqla_compat import _table_for_constraint # noqa
# backwards compat
-from ..util.sqla_compat import ( # noqa
- _table_for_constraint,
- _columns_for_constraint,
- _fk_spec,
- _is_type_bound,
- _find_columns,
-)
if util.sqla_09:
from sqlalchemy.sql.elements import quoted_name
-from sqlalchemy import schema, text
+from sqlalchemy import schema
+from sqlalchemy import text
from sqlalchemy import types as sqltypes
-from ..util.compat import string_types, text_type, with_metaclass
-from ..util import sqla_compat
-from .. import util
from . import base
+from .. import util
+from ..util import sqla_compat
+from ..util.compat import string_types
+from ..util.compat import text_type
+from ..util.compat import with_metaclass
class ImplMeta(type):
+from sqlalchemy import types as sqltypes
from sqlalchemy.ext.compiler import compiles
-
-from .. import util
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import CreateIndex
+from sqlalchemy.sql.expression import ClauseElement
+from sqlalchemy.sql.expression import Executable
+
+from .base import AddColumn
+from .base import alter_column
+from .base import alter_table
+from .base import ColumnDefault
+from .base import ColumnName
+from .base import ColumnNullable
+from .base import ColumnType
+from .base import format_column_name
+from .base import format_server_default
+from .base import format_table_name
+from .base import format_type
+from .base import RenameTable
from .impl import DefaultImpl
-from .base import (
- alter_table,
- AddColumn,
- ColumnName,
- RenameTable,
- format_table_name,
- format_column_name,
- ColumnNullable,
- alter_column,
- format_server_default,
- ColumnDefault,
- format_type,
- ColumnType,
-)
-from sqlalchemy.sql.expression import ClauseElement, Executable
-from sqlalchemy.schema import CreateIndex, Column
-from sqlalchemy import types as sqltypes
+from .. import util
class MSSQLImpl(DefaultImpl):
-from sqlalchemy.ext.compiler import compiles
-from sqlalchemy import types as sqltypes
+import re
+
from sqlalchemy import schema
+from sqlalchemy import types as sqltypes
+from sqlalchemy.ext.compiler import compiles
-from ..util.compat import string_types
-from .. import util
-from .impl import DefaultImpl
-from .base import (
- ColumnNullable,
- ColumnName,
- ColumnDefault,
- ColumnType,
- AlterColumn,
- format_column_name,
- format_server_default,
-)
from .base import alter_table
+from .base import AlterColumn
+from .base import ColumnDefault
+from .base import ColumnName
+from .base import ColumnNullable
+from .base import ColumnType
+from .base import format_column_name
+from .base import format_server_default
+from .impl import DefaultImpl
+from .. import util
from ..autogenerate import compare
-from ..util.sqla_compat import _is_type_bound, sqla_100
-import re
+from ..util.compat import string_types
+from ..util.sqla_compat import _is_type_bound
+from ..util.sqla_compat import sqla_100
class MySQLImpl(DefaultImpl):
from sqlalchemy.ext.compiler import compiles
+from .base import AddColumn
+from .base import alter_table
+from .base import ColumnDefault
+from .base import ColumnName
+from .base import ColumnNullable
+from .base import ColumnType
+from .base import format_column_name
+from .base import format_server_default
+from .base import format_type
from .impl import DefaultImpl
-from .base import (
- alter_table,
- AddColumn,
- ColumnName,
- format_column_name,
- ColumnNullable,
- format_server_default,
- ColumnDefault,
- format_type,
- ColumnType,
-)
class OracleImpl(DefaultImpl):
+import logging
import re
-from ..util import compat
-from .. import util
-from .base import (
- compiles,
- alter_column,
- alter_table,
- format_table_name,
- format_type,
- AlterColumn,
- RenameTable,
-)
-from .impl import DefaultImpl
-from sqlalchemy.dialects.postgresql import INTEGER, BIGINT
-from ..autogenerate import render
-from sqlalchemy import text, Numeric, Column
+from sqlalchemy import Column
+from sqlalchemy import Numeric
+from sqlalchemy import text
+from sqlalchemy import types as sqltypes
+from sqlalchemy.dialects.postgresql import BIGINT
+from sqlalchemy.dialects.postgresql import INTEGER
from sqlalchemy.sql.expression import ColumnClause
+from sqlalchemy.sql.expression import UnaryExpression
from sqlalchemy.types import NULLTYPE
-from sqlalchemy import types as sqltypes
-from ..operations.base import Operations
-from ..operations.base import BatchOperations
+from .base import alter_column
+from .base import alter_table
+from .base import AlterColumn
+from .base import compiles
+from .base import format_table_name
+from .base import format_type
+from .base import RenameTable
+from .impl import DefaultImpl
+from .. import util
+from ..autogenerate import render
from ..operations import ops
-from ..util import sqla_compat
from ..operations import schemaobj
-
-import logging
-
-from sqlalchemy.sql.expression import UnaryExpression
+from ..operations.base import BatchOperations
+from ..operations.base import Operations
+from ..util import compat
+from ..util import sqla_compat
if util.sqla_100:
from sqlalchemy.dialects.postgresql import ExcludeConstraint
info = inspector.bind.execute(
text(
"select c.relname, a.attname "
- "from pg_class as c join pg_depend d on d.objid=c.oid and "
+ "from pg_class as c join "
+ "pg_depend d on d.objid=c.oid and "
"d.classid='pg_class'::regclass and "
"d.refclassid='pg_class'::regclass "
"join pg_class t on t.oid=d.refobjid "
-from .. import util
-from .impl import DefaultImpl
import re
+from .impl import DefaultImpl
+from .. import util
+
class SQLiteImpl(DefaultImpl):
__dialect__ = "sqlite"
-from .base import Operations, BatchOperations
+from .base import BatchOperations
+from .base import Operations
from .ops import MigrateOperation
-from . import toimpl
+from . import toimpl # noqa
__all__ = ["Operations", "BatchOperations", "MigrateOperation"]
from contextlib import contextmanager
+import textwrap
-from .. import util
-from ..util import sqla_compat
from . import batch
from . import schemaobj
+from .. import util
+from ..util import sqla_compat
from ..util.compat import exec_
from ..util.compat import inspect_formatargspec
from ..util.compat import inspect_getargspec
-import textwrap
__all__ = ("Operations", "BatchOperations")
-from sqlalchemy import (
- Table,
- MetaData,
- Index,
- select,
- Column,
- ForeignKeyConstraint,
- PrimaryKeyConstraint,
- cast,
- CheckConstraint,
-)
-from sqlalchemy import types as sqltypes
+from sqlalchemy import cast
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import Index
+from sqlalchemy import MetaData
+from sqlalchemy import PrimaryKeyConstraint
from sqlalchemy import schema as sql_schema
-from sqlalchemy.util import OrderedDict
-from .. import util
+from sqlalchemy import select
+from sqlalchemy import Table
+from sqlalchemy import types as sqltypes
from sqlalchemy.events import SchemaEventTarget
-from ..util.sqla_compat import (
- _columns_for_constraint,
- _is_type_bound,
- _fk_is_self_referential,
- _remove_column_from_collection,
-)
+from sqlalchemy.util import OrderedDict
+
+from ..util.sqla_compat import _columns_for_constraint
+from ..util.sqla_compat import _fk_is_self_referential
+from ..util.sqla_compat import _is_type_bound
+from ..util.sqla_compat import _remove_column_from_collection
class BatchOperationsImpl(object):
+import re
+
+from sqlalchemy.types import NULLTYPE
+
+from . import schemaobj
+from .base import BatchOperations
+from .base import Operations
from .. import util
from ..util import sqla_compat
-from . import schemaobj
-from sqlalchemy.types import NULLTYPE
-from .base import Operations, BatchOperations
-import re
class MigrateOperation(object):
if constraint.use_alter:
kw["use_alter"] = constraint.use_alter
- source_schema, source_table, source_columns, target_schema, target_table, target_columns, onupdate, ondelete, deferrable, initially = sqla_compat._fk_spec(
- constraint
- )
+ (
+ source_schema,
+ source_table,
+ source_columns,
+ target_schema,
+ target_table,
+ target_columns,
+ onupdate,
+ ondelete,
+ deferrable,
+ initially,
+ ) = sqla_compat._fk_spec(constraint)
kw["source_schema"] = source_schema
kw["referent_schema"] = target_schema
cname,
{
"existing_nullable": self.existing_nullable,
- "existing_server_default": self.existing_server_default,
+ "existing_server_default": (
+ self.existing_server_default
+ ),
},
self.existing_type,
self.modify_type,
cname,
{
"existing_type": self.existing_type,
- "existing_server_default": self.existing_server_default,
+ "existing_server_default": (
+ self.existing_server_default
+ ),
},
self.existing_nullable,
self.modify_nullable,
@classmethod
def execute(cls, operations, sqltext, execution_options=None):
- """Execute the given SQL using the current migration context.
+ r"""Execute the given SQL using the current migration context.
The given SQL can be a plain string, e.g.::
from sqlalchemy import schema as sa_schema
-from sqlalchemy.types import NULLTYPE, Integer
-from ..util.compat import string_types
+from sqlalchemy.types import Integer
+from sqlalchemy.types import NULLTYPE
+
from .. import util
+from ..util.compat import string_types
class SchemaObjects(object):
-from . import ops
+from sqlalchemy import schema as sa_schema
from . import Operations
-from sqlalchemy import schema as sa_schema
+from . import ops
@Operations.implementation_for(ops.AlterColumnOp)
-from ..operations import Operations
from .migration import MigrationContext
from .. import util
+from ..operations import Operations
class EnvironmentContext(util.ModuleClsProxy):
+from contextlib import contextmanager
import logging
import sys
-from contextlib import contextmanager
-from sqlalchemy import (
- MetaData,
- Table,
- Column,
- String,
- literal_column,
- PrimaryKeyConstraint,
-)
-from sqlalchemy.engine.strategies import MockEngineStrategy
-from sqlalchemy.engine import url as sqla_url
+from sqlalchemy import Column
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import String
+from sqlalchemy import Table
from sqlalchemy.engine import Connection
+from sqlalchemy.engine import url as sqla_url
+from sqlalchemy.engine.strategies import MockEngineStrategy
-from ..util.compat import callable, EncodedIO
-from .. import ddl, util
+from .. import ddl
+from .. import util
+from ..util.compat import callable
+from ..util.compat import EncodedIO
log = logging.getLogger(__name__)
@property
def up_revision(self):
- """Get :attr:`~.MigrationInfo.up_revision_id` as a :class:`.Revision`."""
+ """Get :attr:`~.MigrationInfo.up_revision_id` as
+ a :class:`.Revision`.
+
+ """
return self.revision_map.get_revision(self.up_revision_id)
@property
-from .base import ScriptDirectory, Script # noqa
+from .base import Script # noqa
+from .base import ScriptDirectory # noqa
__all__ = ["ScriptDirectory", "Script"]
+from contextlib import contextmanager
import datetime
-from dateutil import tz
import os
import re
import shutil
-from .. import util
-from ..util import compat
+
+from dateutil import tz
+
from . import revision
+from .. import util
from ..runtime import migration
-
-from contextlib import contextmanager
+from ..util import compat
_sourceless_rev_file = re.compile(r"(?!\.\#|__init__)(.*\.py)(c|o)?$")
_only_source_rev_file = re.compile(r"(?!\.\#|__init__)(.*\.py)$")
def __init__(
self,
- dir,
+ dir, # noqa
file_template=_default_file_template,
truncate_slug_length=40,
version_locations=None,
-import re
import collections
+import re
-from .. import util
from sqlalchemy import util as sqlautil
+
+from .. import util
from ..util import compat
_relative_destination = re.compile(r"(?:(.+?)@)?(\w+)?((?:\+|-)\d+)")
from __future__ import with_statement
-from alembic import context
-from sqlalchemy import engine_from_config, pool
+
from logging.config import fileConfig
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
from __future__ import with_statement
-from alembic import context
-from sqlalchemy import engine_from_config, pool
-from logging.config import fileConfig
+
import logging
+from logging.config import fileConfig
import re
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
USE_TWOPHASE = False
# this is the Alembic Config object, which provides
be loaded from there.
"""
-from alembic import context
-from paste.deploy import loadapp
from logging.config import fileConfig
-from sqlalchemy.engine.base import Engine
+
+from paste.deploy import loadapp
+
+from alembic import context
try:
# engine = meta.engine
raise NotImplementedError("Please specify engine connectivity here")
- with engine.connect() as connection:
+ with engine.connect() as connection: # noqa
context.configure(
connection=connection, target_metadata=target_metadata
)
-from .fixtures import TestBase
-from .assertions import (
- eq_,
- ne_,
- is_,
- is_not_,
- assert_raises_message,
- eq_ignore_whitespace,
- assert_raises,
-)
-
-from .util import provide_metadata
-
-from alembic import util
-
-
-from .config import requirements as requires
+from alembic import util # noqa
+from .assertions import assert_raises # noqa
+from .assertions import assert_raises_message # noqa
+from .assertions import eq_ # noqa
+from .assertions import eq_ignore_whitespace # noqa
+from .assertions import is_ # noqa
+from .assertions import is_not_ # noqa
+from .assertions import ne_ # noqa
+from .config import requirements as requires # noqa
+from .fixtures import TestBase # noqa
+from .util import provide_metadata # noqa
from __future__ import absolute_import
-
+import contextlib
import re
-from .. import util
+import warnings
+
+from sqlalchemy import exc as sa_exc
from sqlalchemy.engine import default
-from ..util.compat import text_type, py3k
-import contextlib
from sqlalchemy.util import decorator
-from sqlalchemy import exc as sa_exc
-import warnings
+
+from . import config
from . import mock
from .exclusions import db_spec
-from . import config
+from .. import util
+from ..util.compat import py3k
+from ..util.compat import text_type
if not util.sqla_094:
else:
- from sqlalchemy.testing.assertions import (
- eq_,
- ne_,
- is_,
- is_not_,
- assert_raises_message,
- assert_raises,
- )
+ from sqlalchemy.testing.assertions import assert_raises # noqa
+ from sqlalchemy.testing.assertions import assert_raises_message # noqa
+ from sqlalchemy.testing.assertions import eq_ # noqa
+ from sqlalchemy.testing.assertions import is_ # noqa
+ from sqlalchemy.testing.assertions import is_not_ # noqa
+ from sqlalchemy.testing.assertions import ne_ # noqa
def eq_ignore_whitespace(a, b, msg=None):
import shutil
import textwrap
-from ..util.compat import u, has_pep3147, get_current_bytecode_suffixes
-from ..script import Script, ScriptDirectory
-from .. import util
from . import engines
from . import provision
+from .. import util
+from ..script import Script
+from ..script import ScriptDirectory
+from ..util.compat import get_current_bytecode_suffixes
+from ..util.compat import has_pep3147
+from ..util.compat import u
def _get_staging_directory():
"""
+import contextlib
import operator
-from .plugin.plugin_base import SkipTest
+
+from sqlalchemy import util
from sqlalchemy.util import decorator
+
from . import config
-from sqlalchemy import util
+from .compat import get_url_backend_name
+from .compat import get_url_driver_name
+from .plugin.plugin_base import SkipTest
from ..util import compat
-import inspect
-import contextlib
-from .compat import get_url_driver_name, get_url_backend_name
def skip_if(predicate, reason=None):
return OrPredicate([Predicate.as_predicate(db) for db in dbs])
-def open():
+def open(): # noqa
return skip_if(BooleanPredicate(False, "mark as execute"))
# coding: utf-8
+from contextlib import contextmanager
import io
import re
-from sqlalchemy import create_engine, text, MetaData
+from sqlalchemy import create_engine
+from sqlalchemy import MetaData
+from sqlalchemy import text
import alembic
-from ..util.compat import configparser
+from . import mock
+from .assertions import _get_dialect
+from .assertions import eq_
+from .plugin.plugin_base import SkipTest
from .. import util
-from ..util.compat import string_types, text_type
-from ..migration import MigrationContext
from ..environment import EnvironmentContext
+from ..migration import MigrationContext
from ..operations import Operations
-from contextlib import contextmanager
-from .plugin.plugin_base import SkipTest
-from .assertions import _get_dialect, eq_
-from . import mock
+from ..util.compat import configparser
+from ..util.compat import string_types
+from ..util.compat import text_type
testing_config = configparser.ConfigParser()
testing_config.read(["test.cfg"])
# dialect. If you need multiple, use __unsupported_on__ and invert.
__only_on__ = None
- # A sequence of no-arg callables. If any are True, the entire testcase is
- # skipped.
+ # A sequence of no-arg callables. If any are True, the entire
+ # testcase is skipped.
__skip_if__ = None
def assert_(self, val, msg=None):
else:
- from sqlalchemy.testing.fixtures import TestBase
+ from sqlalchemy.testing.fixtures import TestBase # noqa
def capture_db():
"""Import stub for mock library.
- NOTE: copied/adapted from SQLAlchemy master for backwards compatibility;
- this should be removable when Alembic targets SQLAlchemy 1.0.0
+ .. note::
+
+ copied/adapted from SQLAlchemy master for backwards compatibility;
+ this should be removable when Alembic targets SQLAlchemy 1.0.0
"""
from __future__ import absolute_import
+
from ..util.compat import py3k
if py3k:
from __future__ import absolute_import
+import re
+import sys
+
try:
# unitttest has a SkipTest also but pytest doesn't
# honor it unless nose is imported too...
SkipTest = skip.Exception
-import sys
-import re
-
py3k = sys.version_info.major >= 3
if py3k:
# late imports, has to happen after config as well
# as nose plugins like coverage
- global util, fixtures, engines, exclusions, assertions, warnings, profiling, config, testing
+ global util, fixtures, engines, exclusions, assertions
+ global warnings, profiling, config, testing
from alembic.testing import config, warnings, exclusions # noqa
from alembic.testing import engines, fixtures # noqa
from sqlalchemy import util # noqa
# assume we're a package, use traditional import
from . import plugin_base
-import sys
-
-py3k = sys.version_info.major >= 3
-
-import pytest
import argparse
-import inspect
import collections
+import inspect
import os
+import sys
+
+import pytest
+
+py3k = sys.version_info.major >= 3
try:
import xdist # noqa
dest,
default=False,
required=False,
- help=None,
+ help=None, # noqa
):
super(CallableAction, self).__init__(
option_strings=option_strings,
"""NOTE: copied/adapted from SQLAlchemy master for backwards compatibility;
this should be removable when Alembic targets SQLAlchemy 1.0.0
"""
-from sqlalchemy.engine import url as sa_url
-from sqlalchemy import create_engine
-from sqlalchemy import text
-from sqlalchemy import exc
-from ..util import compat
-from . import config, engines
-from .compat import get_url_backend_name
import collections
+import logging
import os
import time
-import logging
+
+from sqlalchemy import create_engine
+from sqlalchemy import exc
+from sqlalchemy import text
+from sqlalchemy.engine import url as sa_url
+
+from . import config
+from . import engines
+from .compat import get_url_backend_name
+from ..util import compat
log = logging.getLogger(__name__)
from alembic import util
-
from . import exclusions
if util.sqla_094:
SQLAlchemy itself is possible.
"""
-from .plugin.noseplugin import NoseSQLAlchemy
import nose
+from .plugin.noseplugin import NoseSQLAlchemy
+
def main():
nose.main(addplugins=[NoseSQLAlchemy()])
from __future__ import absolute_import
+import re
import warnings
+
from sqlalchemy import exc as sa_exc
-import re
def setup_filters():
-from .langhelpers import ( # noqa
- asbool,
- rev_id,
- to_tuple,
- to_list,
- memoized_property,
- dedupe_tuple,
- immutabledict,
- _with_legacy_names,
- Dispatcher,
- ModuleClsProxy,
-)
-from .messaging import ( # noqa
- write_outstream,
- status,
- err,
- obfuscate_url_pw,
- warn,
- msg,
- format_as_comma,
-)
-from .pyfiles import ( # noqa
- template_to_file,
- coerce_resource_to_filename,
- pyc_file_from_path,
- load_python_file,
- edit,
-)
-from .sqla_compat import ( # noqa
- sqla_09,
- sqla_092,
- sqla_094,
- sqla_099,
- sqla_100,
- sqla_105,
- sqla_110,
- sqla_1010,
- sqla_1014,
- sqla_1115,
-)
from .exc import CommandError
+from .langhelpers import _with_legacy_names # noqa
+from .langhelpers import asbool # noqa
+from .langhelpers import dedupe_tuple # noqa
+from .langhelpers import Dispatcher # noqa
+from .langhelpers import immutabledict # noqa
+from .langhelpers import memoized_property # noqa
+from .langhelpers import ModuleClsProxy # noqa
+from .langhelpers import rev_id # noqa
+from .langhelpers import to_list # noqa
+from .langhelpers import to_tuple # noqa
+from .messaging import err # noqa
+from .messaging import format_as_comma # noqa
+from .messaging import msg # noqa
+from .messaging import obfuscate_url_pw # noqa
+from .messaging import status # noqa
+from .messaging import warn # noqa
+from .messaging import write_outstream # noqa
+from .pyfiles import coerce_resource_to_filename # noqa
+from .pyfiles import edit # noqa
+from .pyfiles import load_python_file # noqa
+from .pyfiles import pyc_file_from_path # noqa
+from .pyfiles import template_to_file # noqa
+from .sqla_compat import sqla_09 # noqa
+from .sqla_compat import sqla_092 # noqa
+from .sqla_compat import sqla_094 # noqa
+from .sqla_compat import sqla_099 # noqa
+from .sqla_compat import sqla_100 # noqa
+from .sqla_compat import sqla_1010 # noqa
+from .sqla_compat import sqla_1014 # noqa
+from .sqla_compat import sqla_105 # noqa
+from .sqla_compat import sqla_110 # noqa
+from .sqla_compat import sqla_1115 # noqa
if not sqla_09:
binary_type = bytes
text_type = str
- def callable(fn):
+ def callable(fn): # noqa
return hasattr(fn, "__call__")
def u(s):
def ue(s):
return s
- range = range
+ range = range # noqa
else:
import __builtin__ as compat_builtins
- string_types = (basestring,)
+ string_types = (basestring,) # noqa
binary_type = str
- text_type = unicode
- callable = callable
+ text_type = unicode # noqa
+ callable = callable # noqa
def u(s):
- return unicode(s, "utf-8")
+ return unicode(s, "utf-8") # noqa
def ue(s):
- return unicode(s, "unicode_escape")
+ return unicode(s, "unicode_escape") # noqa
- range = xrange
+ range = xrange # noqa
if py33:
import collections.abc as collections_abc
else:
- import collections as collections_abc
+ import collections as collections_abc # noqa
if py3k:
import collections
else:
- from inspect import formatargspec as inspect_formatargspec
+ from inspect import formatargspec as inspect_formatargspec # noqa
if py3k:
+import collections
import textwrap
-import warnings
import uuid
-import collections
+import warnings
+from .compat import callable
from .compat import collections_abc
-
-from .compat import callable, exec_, string_types, with_metaclass
-
-from .compat import inspect_getargspec
+from .compat import exec_
from .compat import inspect_formatargspec
+from .compat import inspect_getargspec
+from .compat import string_types
+from .compat import with_metaclass
class _ModuleClsMeta(type):
-from .compat import py27, binary_type, string_types
-from .compat import collections_abc
-
+import logging
import sys
-from sqlalchemy.engine import url
-import warnings
import textwrap
-import logging
+import warnings
+
+from sqlalchemy.engine import url
+
+from .compat import binary_type
+from .compat import collections_abc
+from .compat import py27
+from .compat import string_types
log = logging.getLogger(__name__)
-import sys
import os
import re
-from .compat import (
- load_module_py,
- load_module_pyc,
- get_current_bytecode_suffixes,
- has_pep3147,
-)
-from mako.template import Template
-from mako import exceptions
import tempfile
+
+from mako import exceptions
+from mako.template import Template
+
+from .compat import get_current_bytecode_suffixes
+from .compat import has_pep3147
+from .compat import load_module_py
+from .compat import load_module_pyc
from .exc import CommandError
import re
+
from sqlalchemy import __version__
-from sqlalchemy.schema import ForeignKeyConstraint, CheckConstraint, Column
+from sqlalchemy import schema
+from sqlalchemy import sql
from sqlalchemy import types as sqltypes
-from sqlalchemy import schema, sql
-from sqlalchemy.sql.visitors import traverse
from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.schema import CheckConstraint
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import ForeignKeyConstraint
from sqlalchemy.sql.expression import _BindParamClause
from sqlalchemy.sql.expression import _TextClause as TextClause
+from sqlalchemy.sql.visitors import traverse
+
from . import compat
where = tests
[flake8]
-show-source = true
enable-extensions = G
# E203 is due to https://github.com/PyCQA/pycodestyle/issues/373
ignore =
-from setuptools import setup, find_packages
-from setuptools.command.test import test as TestCommand
import os
import re
import sys
+from setuptools import find_packages
+from setuptools import setup
+from setuptools.command.test import test as TestCommand
+
v = open(os.path.join(os.path.dirname(__file__), "alembic", "__init__.py"))
-VERSION = re.compile(r""".*__version__ = ["'](.*?)["']""", re.S).match(v.read()).group(1)
+VERSION = (
+ re.compile(r""".*__version__ = ["'](.*?)["']""", re.S)
+ .match(v.read())
+ .group(1)
+)
v.close()
-from sqlalchemy import (
- MetaData,
- Column,
- Table,
- Integer,
- String,
- Text,
- Numeric,
- CHAR,
- ForeignKey,
- Index,
- UniqueConstraint,
- CheckConstraint,
- text,
-)
+from sqlalchemy import CHAR
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import event
+from sqlalchemy import ForeignKey
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Numeric
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import Text
+from sqlalchemy import text
+from sqlalchemy import UniqueConstraint
from sqlalchemy.engine.reflection import Inspector
-from alembic.operations import ops
from alembic import autogenerate
+from alembic import util
+from alembic.autogenerate import api
+from alembic.ddl.base import _fk_spec
from alembic.migration import MigrationContext
+from alembic.operations import ops
from alembic.testing import config
-from alembic.testing.env import staging_env, clear_staging_env
from alembic.testing import eq_
-from alembic.ddl.base import _fk_spec
-from alembic.autogenerate import api
-from alembic import util
-from sqlalchemy import event
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
names_in_this_test = set()
-from alembic.script.revision import RevisionMap, Revision
+from alembic.script.revision import Revision
+from alembic.script.revision import RevisionMap
data = [
Revision("3fc8a578bc0a", ("4878cb1cb7f6", "454a0529f84e")),
-from alembic.testing.requirements import SuiteRequirements
-from alembic.testing import exclusions
from alembic import util
+from alembic.testing import exclusions
+from alembic.testing.requirements import SuiteRequirements
from alembic.util import sqla_compat
from alembic import autogenerate
from alembic.migration import MigrationContext
-from alembic.testing import TestBase
from alembic.testing import eq_
-
-from ._autogen_fixtures import AutogenTest, ModelOne, _default_include_object
+from alembic.testing import TestBase
+from ._autogen_fixtures import _default_include_object
+from ._autogen_fixtures import AutogenTest
+from ._autogen_fixtures import ModelOne
class AutogenerateDiffTest(ModelOne, AutogenTest, TestBase):
batch_op.drop_index('pw_idx')
batch_op.drop_column('pw')
- # ### end Alembic commands ###""",
+ # ### end Alembic commands ###""" # noqa,
)
eq_(
sa.ForeignKeyConstraint(['uid'], ['user.id'], )
)
op.drop_table('item')
- # ### end Alembic commands ###""",
+ # ### end Alembic commands ###""" # noqa,
)
def test_imports_maintined(self):
schema='%(schema)s'
)
op.drop_table('item', schema='%(schema)s')
- # ### end Alembic commands ###"""
+ # ### end Alembic commands ###""" # noqa
% {"schema": self.schema},
)
import sys
-from sqlalchemy import (
- MetaData,
- Column,
- Table,
- Integer,
- String,
- Text,
- Numeric,
- CHAR,
- ForeignKey,
- INTEGER,
- Index,
- UniqueConstraint,
- TypeDecorator,
- CheckConstraint,
- text,
- PrimaryKeyConstraint,
- ForeignKeyConstraint,
- VARCHAR,
- DECIMAL,
- DateTime,
- BigInteger,
- BIGINT,
- SmallInteger,
-)
+from sqlalchemy import BIGINT
+from sqlalchemy import BigInteger
+from sqlalchemy import CHAR
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import DateTime
+from sqlalchemy import DECIMAL
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import Index
+from sqlalchemy import INTEGER
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Numeric
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import SmallInteger
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import Text
+from sqlalchemy import text
+from sqlalchemy import TypeDecorator
+from sqlalchemy import UniqueConstraint
+from sqlalchemy import VARCHAR
from sqlalchemy.dialects import sqlite
-from sqlalchemy.types import NULLTYPE, VARBINARY
from sqlalchemy.engine.reflection import Inspector
+from sqlalchemy.types import NULLTYPE
+from sqlalchemy.types import VARBINARY
-from alembic.operations import ops
from alembic import autogenerate
from alembic.migration import MigrationContext
-from alembic.testing import TestBase
-from alembic.testing import config
+from alembic.operations import ops
from alembic.testing import assert_raises_message
-from alembic.testing.mock import Mock, patch
-from alembic.testing import eq_, is_, is_not_
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing import is_
+from alembic.testing import is_not_
+from alembic.testing import TestBase
+from alembic.testing.mock import Mock
from alembic.util import CommandError
-from ._autogen_fixtures import AutogenTest, AutogenFixtureTest
+from ._autogen_fixtures import AutogenFixtureTest
+from ._autogen_fixtures import AutogenTest
py3k = sys.version_info >= (3,)
import sys
-from alembic.testing import TestBase, config, mock
-
-from sqlalchemy import (
- MetaData,
- Column,
- Table,
- Integer,
- String,
- ForeignKeyConstraint,
-)
-from alembic.testing import eq_
-py3k = sys.version_info.major >= 3
+from sqlalchemy import Column
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import String
+from sqlalchemy import Table
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing import mock
+from alembic.testing import TestBase
from ._autogen_fixtures import AutogenFixtureTest
+py3k = sys.version_info.major >= 3
+
class AutogenerateForeignKeysTest(AutogenFixtureTest, TestBase):
__backend__ = True
import sys
-from alembic.testing import TestBase
-from alembic.testing import config
-from alembic.testing import assertions
-from sqlalchemy import (
- MetaData,
- Column,
- Table,
- Integer,
- String,
- Numeric,
- UniqueConstraint,
- Index,
- ForeignKeyConstraint,
- ForeignKey,
- func,
-)
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import func
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Numeric
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import UniqueConstraint
+
+from alembic.testing import assertions
+from alembic.testing import config
from alembic.testing import engines
from alembic.testing import eq_
+from alembic.testing import TestBase
from alembic.testing.env import staging_env
+from ._autogen_fixtures import AutogenFixtureTest
py3k = sys.version_info >= (3,)
-from ._autogen_fixtures import AutogenFixtureTest
-
class NoUqReflection(object):
__requires__ = ()
import re
import sys
-from alembic.testing import TestBase, exclusions, assert_raises
-from alembic.testing import assertions
-
-from alembic.operations import ops
-from sqlalchemy import (
- MetaData,
- Column,
- Table,
- String,
- Numeric,
- CHAR,
- ForeignKey,
- DATETIME,
- Integer,
- BigInteger,
- CheckConstraint,
- Unicode,
- Enum,
- cast,
- DateTime,
- UniqueConstraint,
- Boolean,
- ForeignKeyConstraint,
- PrimaryKeyConstraint,
- Index,
- func,
- text,
- DefaultClause,
-)
-from sqlalchemy.types import TIMESTAMP
+import sqlalchemy as sa # noqa
+from sqlalchemy import BigInteger
+from sqlalchemy import Boolean
+from sqlalchemy import cast
+from sqlalchemy import CHAR
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import DATETIME
+from sqlalchemy import DateTime
+from sqlalchemy import DefaultClause
+from sqlalchemy import Enum
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import func
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Numeric
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import text
from sqlalchemy import types
-from sqlalchemy.types import UserDefinedType
+from sqlalchemy import Unicode
+from sqlalchemy import UniqueConstraint
from sqlalchemy.engine.default import DefaultDialect
-from sqlalchemy.sql import and_, column, literal_column, false, table
-from alembic.migration import MigrationContext
-from alembic.autogenerate import api
+from sqlalchemy.sql import and_
+from sqlalchemy.sql import column
+from sqlalchemy.sql import false
+from sqlalchemy.sql import literal_column
+from sqlalchemy.sql import table
+from sqlalchemy.types import TIMESTAMP
+from sqlalchemy.types import UserDefinedType
+from alembic import autogenerate
+from alembic import op # noqa
+from alembic.autogenerate import api
+from alembic.migration import MigrationContext
+from alembic.operations import ops
+from alembic.testing import assert_raises
+from alembic.testing import assertions
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing import eq_ignore_whitespace
+from alembic.testing import TestBase
+from alembic.testing.fixtures import op_fixture
from alembic.testing.mock import patch
-
-from alembic import autogenerate, util
from alembic.util import compat
-from alembic.testing import eq_, eq_ignore_whitespace, config
-
-from alembic.testing.fixtures import op_fixture
-from alembic import op # noqa
-import sqlalchemy as sa # noqa
py3k = sys.version_info >= (3,)
with self.autogen_context._within_batch():
eq_ignore_whitespace(
autogenerate.render_op_text(self.autogen_context, op_obj),
- "batch_op.create_foreign_key('fk_a_id', 'a', ['a_id'], ['id'])",
+ "batch_op.create_foreign_key"
+ "('fk_a_id', 'a', ['a_id'], ['id'])",
)
def test_add_fk_constraint_kwarg(self):
def test_render_fk_constraint_resolve_key(self):
m = MetaData()
t1 = Table("t", m, Column("c", Integer))
- t2 = Table("t2", m, Column("c_rem", Integer, key="c_remkey"))
+ Table("t2", m, Column("c_rem", Integer, key="c_remkey"))
fk = ForeignKeyConstraint(["c"], ["t2.c_remkey"])
t1.append_constraint(fk)
def test_render_fk_constraint_bad_table_resolve(self):
m = MetaData()
t1 = Table("t", m, Column("c", Integer))
- t2 = Table("t2", m, Column("c_rem", Integer))
+ Table("t2", m, Column("c_rem", Integer))
fk = ForeignKeyConstraint(["c"], ["t2.nonexistent"])
t1.append_constraint(fk)
def test_render_fk_constraint_bad_table_resolve_dont_get_confused(self):
m = MetaData()
t1 = Table("t", m, Column("c", Integer))
- t2 = Table(
+ Table(
"t2",
m,
Column("c_rem", Integer, key="cr_key"),
def test_render_fk_constraint_link_to_name(self):
m = MetaData()
t1 = Table("t", m, Column("c", Integer))
- t2 = Table("t2", m, Column("c_rem", Integer, key="c_remkey"))
+ Table("t2", m, Column("c_rem", Integer, key="c_remkey"))
fk = ForeignKeyConstraint(["c"], ["t2.c_rem"], link_to_name=True)
t1.append_constraint(fk)
from contextlib import contextmanager
import re
-from alembic.testing import exclusions
-from alembic.testing import assert_raises_message
-from alembic.testing import TestBase, eq_, config
-from alembic.testing.fixtures import op_fixture
-from alembic.testing import mock
+from sqlalchemy import Boolean
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import DateTime
+from sqlalchemy import Enum
+from sqlalchemy import exc
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import UniqueConstraint
+from sqlalchemy.engine.reflection import Inspector
+from sqlalchemy.schema import CreateIndex
+from sqlalchemy.schema import CreateTable
+from sqlalchemy.sql import column
+from sqlalchemy.sql import select
+from sqlalchemy.sql import text
+
from alembic.operations import Operations
from alembic.operations.batch import ApplyBatchImpl
from alembic.runtime.migration import MigrationContext
-
-
-from sqlalchemy import (
- Integer,
- Table,
- Column,
- String,
- MetaData,
- ForeignKey,
- UniqueConstraint,
- ForeignKeyConstraint,
- Index,
- Boolean,
- CheckConstraint,
- Enum,
- DateTime,
- PrimaryKeyConstraint,
-)
-from sqlalchemy.engine.reflection import Inspector
-from sqlalchemy.sql import column, text, select
-from sqlalchemy.schema import CreateTable, CreateIndex
-from sqlalchemy import exc
+from alembic.testing import assert_raises_message
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing import exclusions
+from alembic.testing import mock
+from alembic.testing import TestBase
+from alembic.testing.fixtures import op_fixture
class BatchApplyTest(TestBase):
-from unittest import TestCase
-
-from alembic import op
-from sqlalchemy import Integer, String
-from sqlalchemy.sql import table, column
-from sqlalchemy import Table, Column, MetaData
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy.sql import column
+from sqlalchemy.sql import table
from sqlalchemy.types import TypeEngine
-from alembic.testing.fixtures import op_fixture, TestBase
-from alembic.testing import eq_, assert_raises_message, config
+from alembic import op
+from alembic.migration import MigrationContext
+from alembic.testing import assert_raises_message
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing.fixtures import op_fixture
+from alembic.testing.fixtures import TestBase
class BulkInsertTest(TestBase):
)
op.bulk_insert(t1, [{"v1": "row v1"}])
context.assert_(
- "INSERT INTO ins_table (id, v1, v2) VALUES (%(id)s, %(v1)s, %(v2)s)"
+ "INSERT INTO ins_table (id, v1, v2) "
+ "VALUES (%(id)s, %(v1)s, %(v2)s)"
)
def test_bulk_insert_no_rows(self):
__only_on__ = "sqlite"
def setUp(self):
- from sqlalchemy import create_engine
- from alembic.migration import MigrationContext
-
self.conn = config.db.connect()
self.conn.execute(
"""
-from alembic import command
-from io import TextIOWrapper, BytesIO
-from alembic.script import ScriptDirectory
-from alembic import config
-from alembic.testing.fixtures import TestBase, capture_context_buffer
-from alembic.testing.env import (
- staging_env,
- _sqlite_testing_config,
- three_rev_fixture,
- clear_staging_env,
- _no_sql_testing_config,
- _sqlite_file_db,
- write_script,
- env_file_fixture,
-)
-from alembic.testing import eq_, assert_raises_message, mock, assert_raises
-from alembic import util
from contextlib import contextmanager
+from io import BytesIO
+from io import TextIOWrapper
import re
+
from sqlalchemy import exc as sqla_exc
+from alembic import command
+from alembic import config
+from alembic import util
+from alembic.script import ScriptDirectory
+from alembic.testing import assert_raises
+from alembic.testing import assert_raises_message
+from alembic.testing import eq_
+from alembic.testing import mock
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import _sqlite_file_db
+from alembic.testing.env import _sqlite_testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import env_file_fixture
+from alembic.testing.env import staging_env
+from alembic.testing.env import three_rev_fixture
+from alembic.testing.env import write_script
+from alembic.testing.fixtures import capture_context_buffer
+from alembic.testing.fixtures import TestBase
+
class _BufMixin(object):
def _buf_fixture(self):
#!coding: utf-8
-from alembic import config, util
-from alembic.util import compat
+from alembic import config
+from alembic import util
from alembic.migration import MigrationContext
from alembic.operations import Operations
from alembic.script import ScriptDirectory
-from alembic.testing.fixtures import TestBase
-from alembic.testing.mock import Mock, call
-
-from alembic.testing import eq_, assert_raises_message
+from alembic.testing import assert_raises_message
+from alembic.testing import eq_
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import _write_config_file
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
from alembic.testing.fixtures import capture_db
-from alembic.testing.env import (
- _no_sql_testing_config,
- clear_staging_env,
- staging_env,
- _write_config_file,
-)
+from alembic.testing.fixtures import TestBase
+from alembic.testing.mock import call
+from alembic.testing.mock import Mock
+from alembic.util import compat
class FileConfigTest(TestBase):
#!coding: utf-8
-from alembic.script import ScriptDirectory
from alembic.environment import EnvironmentContext
from alembic.migration import MigrationContext
-from alembic.testing.fixtures import TestBase
-from alembic.testing.mock import Mock, call, MagicMock
-from alembic.testing.env import (
- _no_sql_testing_config,
- staging_env,
- clear_staging_env,
- write_script,
- _sqlite_file_db,
-)
+from alembic.script import ScriptDirectory
+from alembic.testing import eq_
+from alembic.testing import is_
from alembic.testing.assertions import expect_warnings
-
-from alembic.testing import eq_, is_
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import _sqlite_file_db
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
+from alembic.testing.env import write_script
+from alembic.testing.fixtures import TestBase
+from alembic.testing.mock import call
+from alembic.testing.mock import MagicMock
+from alembic.testing.mock import Mock
class EnvironmentTest(TestBase):
-from alembic.testing.fixtures import TestBase
-from alembic.ddl import impl
-from alembic.testing import eq_ignore_whitespace
+from sqlalchemy import MetaData
+from sqlalchemy import types as sqla_types
+from sqlalchemy.engine import default
+
from alembic import autogenerate
+from alembic.autogenerate import api
from alembic.autogenerate import render
+from alembic.ddl import impl
from alembic.migration import MigrationContext
-from alembic.autogenerate import api
from alembic.testing import eq_
-
-from sqlalchemy import types as sqla_types
-from sqlalchemy import MetaData
-from sqlalchemy.engine import default
+from alembic.testing import eq_ignore_whitespace
+from alembic.testing.fixtures import TestBase
class CustomDialect(default.DefaultDialect):
self.autogen_context.imports,
set(
[
- "from tests.test_external_dialect import custom_dialect_types"
+ "from tests.test_external_dialect "
+ "import custom_dialect_types"
]
),
)
self.autogen_context.imports,
set(
[
- "from tests.test_external_dialect import custom_dialect_types"
+ "from tests.test_external_dialect "
+ "import custom_dialect_types"
]
),
)
autogenerate.render._repr_type(
EXT_ARRAY(FOOBARTYPE), self.autogen_context
),
- "custom_dialect_types.EXT_ARRAY(custom_dialect_types.FOOBARTYPE())",
+ "custom_dialect_types.EXT_ARRAY"
+ "(custom_dialect_types.FOOBARTYPE())",
)
eq_(
self.autogen_context.imports,
set(
[
- "from tests.test_external_dialect import custom_dialect_types"
+ "from tests.test_external_dialect "
+ "import custom_dialect_types"
]
),
)
"""Test op functions against MSSQL."""
+from sqlalchemy import Column
+from sqlalchemy import Integer
+
+from alembic import command
+from alembic import op
+from alembic import util
+from alembic.testing import assert_raises_message
+from alembic.testing import eq_
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
+from alembic.testing.env import three_rev_fixture
+from alembic.testing.fixtures import capture_context_buffer
+from alembic.testing.fixtures import op_fixture
from alembic.testing.fixtures import TestBase
-from sqlalchemy import Integer, Column
-
-from alembic import op, command, util
-
-from alembic.testing import eq_, assert_raises_message
-from alembic.testing.fixtures import capture_context_buffer, op_fixture
-from alembic.testing.env import (
- staging_env,
- _no_sql_testing_config,
- three_rev_fixture,
- clear_staging_env,
-)
-from alembic.testing import config
-
class FullEnvironmentTests(TestBase):
@classmethod
context.assert_("ALTER TABLE t ALTER COLUMN c INTEGER NOT NULL")
def test_alter_column_nullable_type_required(self):
- context = op_fixture("mssql")
+ op_fixture("mssql")
assert_raises_message(
util.CommandError,
"MS-SQL ALTER COLUMN operations with NULL or "
-from sqlalchemy import Integer, func, Boolean
-from alembic.testing.fixtures import TestBase
-from alembic.testing import config
-from sqlalchemy import TIMESTAMP, MetaData, Table, Column, text
+from sqlalchemy import Boolean
+from sqlalchemy import Column
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Table
+from sqlalchemy import text
+from sqlalchemy import TIMESTAMP
from sqlalchemy.engine.reflection import Inspector
-from alembic import op, util
-
-from alembic.testing import eq_, assert_raises_message
-from alembic.testing.fixtures import capture_context_buffer, op_fixture
-from alembic.testing.env import (
- staging_env,
- _no_sql_testing_config,
- three_rev_fixture,
- clear_staging_env,
-)
+from alembic import op
+from alembic import util
from alembic.migration import MigrationContext
+from alembic.testing import assert_raises_message
+from alembic.testing import config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
+from alembic.testing.fixtures import op_fixture
+from alembic.testing.fixtures import TestBase
class MySQLOpTest(TestBase):
-from alembic.testing.fixtures import TestBase, capture_context_buffer
-
-from alembic import command, util
+import re
+from alembic import command
+from alembic import util
from alembic.testing import assert_raises_message
-from alembic.testing.env import (
- staging_env,
- _no_sql_testing_config,
- three_rev_fixture,
- clear_staging_env,
- env_file_fixture,
- multi_heads_fixture,
-)
-import re
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import env_file_fixture
+from alembic.testing.env import multi_heads_fixture
+from alembic.testing.env import staging_env
+from alembic.testing.env import three_rev_fixture
+from alembic.testing.fixtures import capture_context_buffer
+from alembic.testing.fixtures import TestBase
a = b = c = None
"""Test against the builders in the op.* module."""
-from sqlalchemy import Integer, Column, ForeignKey, Table, String, Boolean
-from sqlalchemy.sql import column, func, text
+from sqlalchemy import Boolean
+from sqlalchemy import Column
from sqlalchemy import event
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy.sql import column
+from sqlalchemy.sql import func
+from sqlalchemy.sql import text
from alembic import op
-from alembic.testing.fixtures import op_fixture
-from alembic.testing import eq_, assert_raises_message, is_
+from alembic.operations import ops
+from alembic.operations import schemaobj
+from alembic.testing import assert_raises_message
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing import is_
from alembic.testing import mock
+from alembic.testing.fixtures import op_fixture
from alembic.testing.fixtures import TestBase
-from alembic.testing import config
-from alembic.operations import schemaobj, ops
@event.listens_for(Table, "after_parent_attach")
"t", "c", server_default=func.utc_thing(func.current_timestamp())
)
context.assert_(
- "ALTER TABLE t ALTER COLUMN c SET DEFAULT utc_thing(CURRENT_TIMESTAMP)"
+ "ALTER TABLE t ALTER COLUMN c "
+ "SET DEFAULT utc_thing(CURRENT_TIMESTAMP)"
)
def test_alter_column_schema_set_compiled_default(self):
.values({"id": op.inline_literal(2)})
)
context.assert_(
- "UPDATE account SET name='account 2' WHERE account.name = 'account 1'",
+ "UPDATE account SET name='account 2' "
+ "WHERE account.name = 'account 1'",
"UPDATE account SET id=2 WHERE account.id = 1",
)
-from sqlalchemy import (
- Integer,
- Column,
- Table,
- Boolean,
- MetaData,
- CheckConstraint,
-)
-from sqlalchemy.sql import column, func
+from sqlalchemy import Boolean
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Table
+from sqlalchemy.sql import column
+from sqlalchemy.sql import func
from alembic import op
-
from alembic.testing.fixtures import op_fixture
from alembic.testing.fixtures import TestBase
context = op_fixture(naming_convention={"uq": "uq_%(table_name)s_foo"})
op.create_unique_constraint(None, "user_table", "x")
context.assert_(
- "ALTER TABLE user_table ADD CONSTRAINT uq_user_table_foo UNIQUE (x)"
+ "ALTER TABLE user_table "
+ "ADD CONSTRAINT uq_user_table_foo UNIQUE (x)"
)
def test_add_index_name_is_none(self):
-from sqlalchemy import Integer, Column
-
-from alembic import op, command
+from sqlalchemy import Column
+from sqlalchemy import Integer
+
+from alembic import command
+from alembic import op
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
+from alembic.testing.env import three_rev_fixture
+from alembic.testing.fixtures import capture_context_buffer
+from alembic.testing.fixtures import op_fixture
from alembic.testing.fixtures import TestBase
-from alembic.testing.fixtures import op_fixture, capture_context_buffer
-from alembic.testing.env import (
- _no_sql_testing_config,
- staging_env,
- three_rev_fixture,
- clear_staging_env,
-)
-
class FullEnvironmentTests(TestBase):
@classmethod
-from sqlalchemy import (
- DateTime,
- MetaData,
- Table,
- Column,
- text,
- Integer,
- String,
- Interval,
- Sequence,
- Numeric,
- BigInteger,
- Float,
- Numeric,
-)
-from sqlalchemy.dialects.postgresql import ARRAY, UUID, BYTEA
-from sqlalchemy.engine.reflection import Inspector
+from sqlalchemy import BigInteger
+from sqlalchemy import Boolean
+from sqlalchemy import Column
+from sqlalchemy import DateTime
+from sqlalchemy import Float
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import Interval
+from sqlalchemy import MetaData
+from sqlalchemy import Numeric
+from sqlalchemy import Sequence
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import text
from sqlalchemy import types
-from alembic.operations import Operations
-from sqlalchemy.sql import table, column
-from alembic.autogenerate.compare import (
- _compare_server_default,
- _compare_tables,
- _render_server_default_for_compare,
-)
+from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.dialects.postgresql import BYTEA
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.engine.reflection import Inspector
+from sqlalchemy.sql import column
+from sqlalchemy.sql import false
+from sqlalchemy.sql import table
-from alembic.operations import ops
-from alembic import command, util
+from alembic import autogenerate
+from alembic import command
+from alembic import op
+from alembic import util
+from alembic.autogenerate import api
+from alembic.autogenerate.compare import _compare_server_default
+from alembic.autogenerate.compare import _compare_tables
+from alembic.autogenerate.compare import _render_server_default_for_compare
from alembic.migration import MigrationContext
+from alembic.operations import Operations
+from alembic.operations import ops
from alembic.script import ScriptDirectory
-from alembic.autogenerate import api
-
-from alembic.testing import eq_, provide_metadata
-from alembic.testing.env import (
- staging_env,
- clear_staging_env,
- _no_sql_testing_config,
- write_script,
-)
-from alembic.testing.fixtures import capture_context_buffer
-from alembic.testing.fixtures import TestBase
-from alembic.testing.fixtures import op_fixture
from alembic.testing import config
-from alembic import op
-from alembic.util import compat
+from alembic.testing import eq_
from alembic.testing import eq_ignore_whitespace
-from alembic import autogenerate
-from sqlalchemy import Index
-from sqlalchemy import Boolean
-from sqlalchemy.sql import false
+from alembic.testing import provide_metadata
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
+from alembic.testing.env import write_script
+from alembic.testing.fixtures import capture_context_buffer
+from alembic.testing.fixtures import op_fixture
+from alembic.testing.fixtures import TestBase
if util.sqla_09:
autogenerate.render._repr_type(
ARRAY(BYTEA, as_tuple=True, dimensions=2), self.autogen_context
),
- "postgresql.ARRAY(postgresql.BYTEA(), as_tuple=True, dimensions=2)",
+ "postgresql.ARRAY(postgresql.BYTEA(), "
+ "as_tuple=True, dimensions=2)",
)
assert (
eq_ignore_whitespace(
autogenerate.render_op_text(autogen_context, op_obj),
- "op.create_exclude_constraint('t_excl_x', 't', (sa.column('x'), '>'), "
+ "op.create_exclude_constraint('t_excl_x', "
+ "'t', (sa.column('x'), '>'), "
"where=sa.text(!U'x != 2'), using='gist')",
)
eq_ignore_whitespace(
autogenerate.render_op_text(autogen_context, op_obj),
- "op.create_exclude_constraint('t_excl_x', 'TTAble', (sa.column('XColumn'), '>'), "
+ "op.create_exclude_constraint('t_excl_x', 'TTAble', "
+ "(sa.column('XColumn'), '>'), "
"where=sa.text(!U'\"XColumn\" != 2'), using='gist')",
)
+from alembic.script.revision import MultipleHeads
+from alembic.script.revision import Revision
+from alembic.script.revision import RevisionError
+from alembic.script.revision import RevisionMap
+from alembic.testing import assert_raises_message
+from alembic.testing import eq_
from alembic.testing.fixtures import TestBase
-from alembic.testing import eq_, assert_raises_message
-from alembic.script.revision import (
- RevisionMap,
- Revision,
- MultipleHeads,
- RevisionError,
-)
from . import _large_map
class LabeledBranchTest(DownIterateTest):
def test_dupe_branch_collection(self):
- fn = lambda: [
- Revision("a", ()),
- Revision("b", ("a",)),
- Revision("c", ("b",), branch_labels=["xy1"]),
- Revision("d", ()),
- Revision("e", ("d",), branch_labels=["xy1"]),
- Revision("f", ("e",)),
- ]
+ def fn():
+ return [
+ Revision("a", ()),
+ Revision("b", ("a",)),
+ Revision("c", ("b",), branch_labels=["xy1"]),
+ Revision("d", ()),
+ Revision("e", ("d",), branch_labels=["xy1"]),
+ Revision("f", ("e",)),
+ ]
assert_raises_message(
RevisionError,
r"Branch name 'xy1' in revision (?:e|c) already "
)
def test_filter_for_lineage_labeled_head_across_merge(self):
- fn = lambda: [
- Revision("a", ()),
- Revision("b", ("a",)),
- Revision("c1", ("b",), branch_labels="c1branch"),
- Revision("c2", ("b",)),
- Revision("d", ("c1", "c2")),
- ]
+ def fn():
+ return [
+ Revision("a", ()),
+ Revision("b", ("a",)),
+ Revision("c1", ("b",), branch_labels="c1branch"),
+ Revision("c2", ("b",)),
+ Revision("d", ("c1", "c2")),
+ ]
map_ = RevisionMap(fn)
c1 = map_.get_revision("c1")
c2 = map_.get_revision("c2")
class MultipleBaseCrossDependencyTestOne(DownIterateTest):
def setUp(self):
"""
-
- base1 -----> a1a -> b1a
- +----> a1b -> b1b
- |
- +-----------+
- |
- v
- base3 -> a3 -> b3
- ^
- |
- +-----------+
- |
- base2 -> a2 -> b2 -> c2 -> d2
-
+ Structure::
+
+ base1 -----> a1a -> b1a
+ +----> a1b -> b1b
+ |
+ +-----------+
+ |
+ v
+ base3 -> a3 -> b3
+ ^
+ |
+ +-----------+
+ |
+ base2 -> a2 -> b2 -> c2 -> d2
"""
self.map = RevisionMap(
# coding: utf-8
+from contextlib import contextmanager
import os
import re
import textwrap
-from alembic import command, util
-from alembic.util import compat
-from alembic.script import ScriptDirectory, Script
-from alembic.testing.env import (
- clear_staging_env,
- staging_env,
- _sqlite_testing_config,
- write_script,
- _sqlite_file_db,
- three_rev_fixture,
- _no_sql_testing_config,
- env_file_fixture,
-)
-from alembic.testing import eq_, assert_raises_message
-from alembic.testing.fixtures import TestBase, capture_context_buffer
+from alembic import command
+from alembic import util
from alembic.environment import EnvironmentContext
-from contextlib import contextmanager
+from alembic.script import Script
+from alembic.script import ScriptDirectory
+from alembic.testing import assert_raises_message
+from alembic.testing import eq_
from alembic.testing import mock
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import _sqlite_file_db
+from alembic.testing.env import _sqlite_testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import env_file_fixture
+from alembic.testing.env import staging_env
+from alembic.testing.env import three_rev_fixture
+from alembic.testing.env import write_script
+from alembic.testing.fixtures import capture_context_buffer
+from alembic.testing.fixtures import TestBase
+from alembic.util import compat
class ApplyVersionsFunctionalTest(TestBase):
-from alembic.testing.fixtures import TestBase
-from alembic.testing import eq_, ne_, assert_raises_message, is_, assertions
-from alembic.testing.env import (
- clear_staging_env,
- staging_env,
- _get_staging_directory,
- _no_sql_testing_config,
- env_file_fixture,
- script_file_fixture,
- _testing_config,
- _sqlite_testing_config,
- three_rev_fixture,
- _multi_dir_testing_config,
- write_script,
- _sqlite_file_db,
- _multidb_testing_config,
-)
-from alembic import command
-from alembic.script import ScriptDirectory
-from alembic.environment import EnvironmentContext
-from alembic.testing import mock
-from alembic import util
-from alembic.operations import ops
-from alembic import autogenerate
-import os
import datetime
+import os
+import re
+
+from dateutil import tz
import sqlalchemy as sa
from sqlalchemy.engine.reflection import Inspector
+
+from alembic import autogenerate
+from alembic import command
+from alembic import util
+from alembic.environment import EnvironmentContext
+from alembic.operations import ops
+from alembic.script import ScriptDirectory
+from alembic.testing import assert_raises_message
+from alembic.testing import assertions
+from alembic.testing import eq_
+from alembic.testing import is_
+from alembic.testing import mock
+from alembic.testing import ne_
+from alembic.testing.env import _get_staging_directory
+from alembic.testing.env import _multi_dir_testing_config
+from alembic.testing.env import _multidb_testing_config
+from alembic.testing.env import _no_sql_testing_config
+from alembic.testing.env import _sqlite_file_db
+from alembic.testing.env import _sqlite_testing_config
+from alembic.testing.env import _testing_config
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import env_file_fixture
+from alembic.testing.env import script_file_fixture
+from alembic.testing.env import staging_env
+from alembic.testing.env import three_rev_fixture
+from alembic.testing.env import write_script
+from alembic.testing.fixtures import TestBase
from alembic.util import CommandError
-import re
-from dateutil import tz
env, abc, def_ = None, None, None
-from alembic.testing.fixtures import op_fixture
-from alembic.testing import assert_raises_message
-from alembic import op
-from sqlalchemy import Integer, Column, Boolean
+from sqlalchemy import Boolean
+from sqlalchemy import Column
+from sqlalchemy import Integer
from sqlalchemy.sql import column
+
+from alembic import op
+from alembic.testing import assert_raises_message
+from alembic.testing.fixtures import op_fixture
from alembic.testing.fixtures import TestBase
-from alembic.testing.fixtures import TestBase
-from alembic.testing import mock
-from alembic.testing import config, eq_, assert_raises, assert_raises_message
-
-from sqlalchemy import Table, MetaData, Column, String
+from sqlalchemy import Column
+from sqlalchemy import MetaData
+from sqlalchemy import String
+from sqlalchemy import Table
from sqlalchemy.engine.reflection import Inspector
-from alembic import migration
+from alembic import migration
+from alembic.testing import assert_raises
+from alembic.testing import assert_raises_message
+from alembic.testing import config
+from alembic.testing import eq_
+from alembic.testing import mock
+from alembic.testing.fixtures import TestBase
from alembic.util import CommandError
version_table = Table(
-from alembic.testing.env import clear_staging_env, staging_env
-from alembic.testing import assert_raises_message, eq_
from alembic import util
-from alembic.testing.fixtures import TestBase
+from alembic.migration import HeadMaintainer
+from alembic.migration import MigrationStep
+from alembic.testing import assert_raises_message
+from alembic.testing import eq_
from alembic.testing import mock
-from alembic.migration import MigrationStep, HeadMaintainer
+from alembic.testing.env import clear_staging_env
+from alembic.testing.env import staging_env
+from alembic.testing.fixtures import TestBase
class MigrationTest(TestBase):
@classmethod
def setup_class(cls):
"""
- a1 ---+
- |
- a2 ---+--> amerge
- |
- a3 ---+
- ^
- |
- +---------------------------+
- |
- b1 ---+ |
- +--> bmerge overmerge / d1
- b2 ---+ | |
- ^ | |
- | | |
- +--------------------------+ |
- |
- +-----------------------------+
- |
- v
- c1 ---+
- |
- c2 ---+--> cmerge
- |
- c3 ---+
+ Structure::
+
+ a1 ---+
+ |
+ a2 ---+--> amerge
+ |
+ a3 ---+
+ ^
+ |
+ +---------------------------+
+ |
+ b1 ---+ |
+ +--> bmerge overmerge / d1
+ b2 ---+ | |
+ ^ | |
+ | | |
+ +--------------------------+ |
+ |
+ +-----------------------------+
+ |
+ v
+ c1 ---+
+ |
+ c2 ---+--> cmerge
+ |
+ c3 ---+
"""
cls.env = env = staging_env()
"""
issue #377
- <base> -> a1 --+--> a2 -------> a3
- | ^ |
- | | +------+
- | | |
- | +---|------+
- | | |
- | v |
- +-------> b1 --> b2 --> b3
+ Structure::
+
+ <base> -> a1 --+--> a2 -------> a3
+ | ^ |
+ | | +------+
+ | | |
+ | +---|------+
+ | | |
+ | v |
+ +-------> b1 --> b2 --> b3
"""
cls.env = env = staging_env()
projects / thirdparty / sqlalchemy / alembic.git / commitdiff
