def test_create_rev_depends_on_branch_label(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg, branch_label="foobar")
rev3 = command.revision(self.cfg, depends_on="foobar")
eq_(rev3.dependencies, "foobar")
eq_(rev3._resolved_dependencies, (rev2.revision,))
def test_create_script_branches_old_template(self):
script = ScriptDirectory.from_config(self.cfg)
with open(os.path.join(script.dir, "script.py.mako"), "w") as file_:
file_.write(
"<%text>#</%text> ${message}\n"
"revision = ${repr(up_revision)}\n"
"down_revision = ${repr(down_revision)}\n"
"def upgrade():\n"
" ${upgrades if upgrades else 'pass'}\n\n"
"def downgrade():\n"
" ${downgrade if downgrades else 'pass'}\n\n"
)
# works OK if no branch names
command.revision(self.cfg, message="some message")
assert_raises_message(
util.CommandError,
r"Version \w+ specified branch_labels foobar, "
r"however the migration file .+?\b does not have them; have you "
"upgraded your script.py.mako to include the 'branch_labels' "
r"section\?",
command.revision,
self.cfg, message="some message", branch_label="foobar"
)
def init_database(app):
settings = None
try:
settings = DBSiteSettings.get_by_id(1)
if not settings or not settings.inited:
raise Exception("Can not get site settings")
if settings.version < DBSiteSettings.VERSION:
raise Exception("Database expired")
except:
from alembic import command
# auto generate alembic version in local
try:
command.revision(app.config["MIGRATE_CFG"],
"database v%s" % DBSiteSettings.VERSION,
True)
except:
logging.exception("migrate revision error")
command.upgrade(app.config["MIGRATE_CFG"], "head")
if not settings:
settings = create_default_settings(app)
else:
settings.inited = True
settings.version = DBSiteSettings.VERSION
settings.save()
app.config["SiteTitle"] = settings.title
app.config["SiteSubTitle"] = settings.subtitle
app.config["OwnerEmail"] = settings.owner
def migrate(app, message=None, autogenerate=False, sql=False, head='head',
splice=False, branch_label=None, version_path=None, rev_id=None):
"""Create new database migration. """
command.revision(app.migrations_config, message, sql=sql, head=head,
autogenerate=autogenerate, splice=splice,
branch_label=branch_label, version_path=version_path,
rev_id=rev_id)
def revision(
directory=None,
message=None,
autogenerate=False,
sql=False,
head="head",
splice=False,
branch_label=None,
version_path=None,
rev_id=None,
):
"""Create a new revision file."""
config = _get_config(directory)
if alembic_version >= (0, 7, 0):
command.revision(
config,
message,
autogenerate=autogenerate,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id,
)
else:
command.revision(config, message, autogenerate=autogenerate, sql=sql)
def migrate(self, directory=None, message=None, sql=False, head='head', splice=False,
branch_label=None, version_path=None, rev_id=None, **kwargs): # pragma: no cover
"""Alias for 'revision --autogenerate'"""
config = _get_config(directory)
command.revision(config, message, autogenerate=True, sql=sql, head=head,
splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
def migrate(
directory=None,
message=None,
sql=False,
head="head",
splice=False,
branch_label=None,
version_path=None,
rev_id=None,
):
"""Alias for 'revision --autogenerate'"""
config = _get_config(directory)
if alembic_version >= (0, 7, 0):
command.revision(
config,
message,
autogenerate=True,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id,
)
else:
command.revision(config, message, autogenerate=True, sql=sql)
def revision(self, directory=None, message=None, autogenerate=False, sql=False,
head='head', splice=False, branch_label=None, version_path=None,
rev_id=None, **kwargs):
"""Create a new revision file."""
config = _get_config(directory)
command.revision(config, message, autogenerate=autogenerate, sql=sql,
head=head, splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
def test_create_rev_autogen_db_not_up_to_date(self):
self._env_fixture()
command.revision(self.cfg)
assert_raises_message(
util.CommandError,
"Target database is not up to date.",
command.revision, self.cfg, autogenerate=True
)
def test_create_rev_invalid_depends_on(self):
self._env_fixture()
command.revision(self.cfg)
assert_raises_message(
util.CommandError,
"Can't locate revision identified by 'invalid'",
command.revision, self.cfg, depends_on='invalid'
)
def test_create_rev_depends_on_partial_revid(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg)
assert len(rev2.revision) > 7
rev3 = command.revision(self.cfg, depends_on=rev2.revision[0:4])
eq_(rev3.dependencies, rev2.revision)
eq_(rev3._resolved_dependencies, (rev2.revision,))
def revision(self, message=None, auto=None):
auto = auto or False
if not message:
raise AlembicCommandError('Please provide a message')
revision_id = self.generate_revision_id()
command.revision(self.config, message=message,
autogenerate=auto, sql=self.offline,
rev_id=revision_id)
def create_new_revision(args, msg=None):
"""Will create a new autogenerated revision file. An returns the
path of the new generated file."""
cfg = get_alembic_config(args)
command.revision(cfg, message=msg, autogenerate=True)
revision_file = get_last_revision_file(args)
while is_locked(revision_file):
time.sleep(1)
return revision_file
def test_autogen(self):
m = sa.MetaData()
sa.Table('t', m, sa.Column('x', sa.Integer))
def process_revision_directives(context, rev, generate_revisions):
existing_upgrades = generate_revisions[0].upgrade_ops
existing_downgrades = generate_revisions[0].downgrade_ops
# model1 will run the upgrades, e.g. create the table,
# model2 will run the downgrades as upgrades, e.g. drop
# the table again
generate_revisions[:] = [
ops.MigrationScript(
util.rev_id(),
existing_upgrades,
ops.DowngradeOps(),
version_path=os.path.join(
_get_staging_directory(), "model1"),
head="model1@head"
),
ops.MigrationScript(
util.rev_id(),
existing_downgrades,
ops.DowngradeOps(),
version_path=os.path.join(
_get_staging_directory(), "model2"),
head="model2@head"
)
]
with self._env_fixture(process_revision_directives, m):
command.upgrade(self.cfg, "heads")
eq_(
Inspector.from_engine(self.engine).get_table_names(),
["alembic_version"]
)
command.revision(
self.cfg, message="some message",
autogenerate=True)
command.upgrade(self.cfg, "model1@head")
eq_(
Inspector.from_engine(self.engine).get_table_names(),
["alembic_version", "t"]
)
command.upgrade(self.cfg, "model2@head")
eq_(
Inspector.from_engine(self.engine).get_table_names(),
["alembic_version"]
)
def actionCreateMigration(self, message=None, auto=True):
from alembic.config import Config
from alembic import command
if not message:
self.parser.error("Please add comment")
alembic_cfg = Config()
alembic_cfg.set_main_option("script_location", "alembic")
alembic_cfg.set_main_option("url", config.DB_URL)
command.revision(alembic_cfg, message=message, autogenerate=auto)
def revision(config, message=None, autogenerate=False, sql=False,
head='head', splice=False, branch_label=None, version_path=None,
rev_id=None):
"""Create a new revision file."""
if alembic_version >= (0, 7, 0):
command.revision(config, message, autogenerate=autogenerate, sql=sql,
head=head, splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
else:
command.revision(config, message, autogenerate=autogenerate, sql=sql)
def migrate(config, message=None, sql=False, head='head', splice=False,
branch_label=None, version_path=None, rev_id=None):
"""Alias for 'revision --autogenerate'"""
setattr(config.cmd_opts, 'autogenerate', True)
if alembic_version >= (0, 7, 0):
command.revision(config, message, autogenerate=True, sql=sql, head=head,
splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
else:
command.revision(config, message, autogenerate=True, sql=sql)
def migrate(context, directory='migrations', message=None, sql=False, head='head', splice=False,
branch_label=None, version_path=None, rev_id=None):
"""Alias for 'revision --autogenerate'"""
config = _get_config(directory, opts=['autogenerate'])
if alembic_version >= (0, 7, 0):
command.revision(config, message, autogenerate=True, sql=sql, head=head,
splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
else:
command.revision(config, message, autogenerate=True, sql=sql)
def run(parser, options, args):
cfg = config.Config()
cfg.set_main_option(
'script_location',
os.path.join(
pkg_resources.require('kansha')[0].location,
'kansha/alembic'
)
)
command.revision(cfg, message=options.message)
def _test_ignore_file_py(self, fname):
command.revision(self.cfg, message="some rev")
script = ScriptDirectory.from_config(self.cfg)
path = os.path.join(script.versions, fname)
with open(path, "w") as f:
f.write("crap, crap -> crap")
command.revision(self.cfg, message="another rev")
script.get_revision("head")
def migrate(directory=None, message=None, sql=False, head='head', splice=False,
branch_label=None, version_path=None, rev_id=None, x_arg=None):
"""Alias for 'revision --autogenerate'"""
config = current_app.extensions['migrate'].migrate.get_config(
directory, opts=['autogenerate'], x_arg=x_arg)
if alembic_version >= (0, 7, 0):
command.revision(config, message, autogenerate=True, sql=sql,
head=head, splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
else:
command.revision(config, message, autogenerate=True, sql=sql)
def revision(directory=None, message=None, autogenerate=False, sql=False,
head='head', splice=False, branch_label=None, version_path=None,
rev_id=None):
"""Create a new revision file."""
config = current_app.extensions['migrate'].migrate.get_config(directory)
if alembic_version >= (0, 7, 0):
command.revision(config, message, autogenerate=autogenerate, sql=sql,
head=head, splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
else:
command.revision(config, message, autogenerate=autogenerate, sql=sql)
def test_pk_constraint_normally_prevents_dupe_rows(self):
self._env_fixture()
command.revision(self.cfg)
r2 = command.revision(self.cfg)
db = _sqlite_file_db()
command.upgrade(self.cfg, "head")
assert_raises(
sqla_exc.IntegrityError,
db.execute,
"insert into alembic_version values ('%s')" % r2.revision,
)
def test_create_rev_depends_on(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg)
rev3 = command.revision(self.cfg, depends_on=rev2.revision)
eq_(rev3._resolved_dependencies, (rev2.revision,))
rev4 = command.revision(
self.cfg, depends_on=[rev2.revision, rev3.revision]
)
eq_(rev4._resolved_dependencies, (rev2.revision, rev3.revision))
def _test_ignore_init_py(self, ext):
"""test that __init__.py is ignored."""
command.revision(self.cfg, message="some rev")
script = ScriptDirectory.from_config(self.cfg)
path = os.path.join(script.versions, "__init__.%s" % ext)
with open(path, "w") as f:
f.write("crap, crap -> crap")
command.revision(self.cfg, message="another rev")
script.get_revision("head")
def test_create_rev_plain_post_merge(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg)
command.revision(self.cfg)
command.revision(self.cfg, head=rev2.revision, splice=True)
command.merge(self.cfg, "heads")
command.revision(self.cfg)
def revision(context, directory='migrations', message=None, autogenerate=False, sql=False,
head='head', splice=False, branch_label=None, version_path=None, rev_id=None):
"""Create a new revision file."""
from app import create_app
with create_app().app_context():
config = _get_config(directory)
if alembic_version >= (0, 7, 0):
command.revision(config, message, autogenerate=autogenerate, sql=sql,
head=head, splice=splice, branch_label=branch_label,
version_path=version_path, rev_id=rev_id)
else:
command.revision(config, message, autogenerate=autogenerate, sql=sql)
def test_create_rev_autogenerate_post_merge(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg)
command.revision(self.cfg)
command.revision(self.cfg, head=rev2.revision, splice=True)
command.merge(self.cfg, "heads")
command.upgrade(self.cfg, "heads")
command.revision(self.cfg, autogenerate=True)
def test_err_correctly_raised_on_dupe_rows(self):
self._env_fixture()
command.revision(self.cfg)
r2 = command.revision(self.cfg)
db = _sqlite_file_db()
command.upgrade(self.cfg, "head")
db.execute("insert into alembic_version values ('%s')" % r2.revision)
assert_raises_message(
util.CommandError,
"Online migration expected to match one row when "
"updating .* in 'alembic_version'; 2 found",
command.downgrade, self.cfg, "-1"
)
def revision():
parser = argparse.ArgumentParser(description='Create a new db revision')
parser.add_argument('dburl', help='Database URL for SQLAlchemy')
parser.add_argument('message', help='Message for the new version')
parser.add_argument('--autogenerate', help='Autogenerate',
action='store_true')
args = parser.parse_args()
repositories.sa_pixort_data(url=args.dburl)
command.revision(
_get_config(args.dburl),
message=args.message,
autogenerate=args.autogenerate)
def test_new_locations_no_autogen(self):
m = sa.MetaData()
def process_revision_directives(context, rev, generate_revisions):
generate_revisions[:] = [
ops.MigrationScript(
util.rev_id(),
ops.UpgradeOps(),
ops.DowngradeOps(),
version_path=os.path.join(
_get_staging_directory(), "model1"
),
head="model1@head",
),
ops.MigrationScript(
util.rev_id(),
ops.UpgradeOps(),
ops.DowngradeOps(),
version_path=os.path.join(
_get_staging_directory(), "model2"
),
head="model2@head",
),
ops.MigrationScript(
util.rev_id(),
ops.UpgradeOps(),
ops.DowngradeOps(),
version_path=os.path.join(
_get_staging_directory(), "model3"
),
head="model3@head",
),
]
with self._env_fixture(process_revision_directives, m):
revs = command.revision(self.cfg, message="some message")
script = ScriptDirectory.from_config(self.cfg)
for rev, model in [
(revs[0], "model1"),
(revs[1], "model2"),
(revs[2], "model3"),
]:
rev_script = script.get_revision(rev.revision)
eq_(
rev_script.path,
os.path.abspath(
os.path.join(
_get_staging_directory(),
model,
"%s_.py" % (rev_script.revision,),
)
),
)
assert os.path.exists(rev_script.path)
def create_db_revision():
"""Genereting alembic database migration script"""
try:
logger.info('Database does not fit metadata. Creating revision')
rand = int(uuid.uuid4()) % 100000000000000
rand_str = str(hex(rand)[2:-1])
this.revision_id = 'v' + this.final_version + '_' + rand_str
message = ''
label = 'v' + this.final_version
command.revision(ax_migration.alembic_cfg,
message,
rev_id=this.revision_id,
autogenerate=True,
branch_label=label)
this.app_yaml['env_variables']['AX_DB_REVISION'] = this.revision_id
except Exception:
logger.exception('Error in creating database revision')
raise
def test_create_script_splice(self):
rev = command.revision(self.cfg,
message="some message",
head=self.b,
splice=True)
script = ScriptDirectory.from_config(self.cfg)
rev = script.get_revision(rev.revision)
eq_(rev.down_revision, self.b)
assert "some message" in rev.doc
eq_(set(script.get_heads()), set([rev.revision, self.c]))
def test_create_rev_autogen_db_not_up_to_date(self):
self._env_fixture()
assert command.revision(self.cfg)
assert_raises_message(
util.CommandError,
"Target database is not up to date.",
command.revision,
self.cfg,
autogenerate=True,
)
def test_running_comments_not_in_sql(self):
message = "this is a very long \nand multiline\nmessage"
d = command.revision(self.cfg, message=message)
with capture_context_buffer(transactional_ddl=True) as buf:
command.upgrade(self.cfg, "%s:%s" % (a, d.revision), sql=True)
assert not re.match(r".*-- .*and multiline", buf.getvalue(),
re.S | re.M)
def make_migration(args_):
target_db_setup(args_.target_db, args_.target_db_user, args_.target_db_password, args_.target_db_host,
args_.target_db_port, args_.db_name)
if not schema_verification():
sys.exit()
tables_ = create_tables_from_rules(True)
config = alembic.config.Config("./alembic.ini")
config.set_main_option("sqlalchemy.url", target_db)
config.set_main_option("script_location", "./migrate")
script = ScriptDirectory.from_config(config)
head_revision = ""
try:
command.revision(config, autogenerate=True)
head_revision = script.get_current_head()
migrate()
except FileNotFoundError as Error:
print("Error Occurred")
print(Error)
print("Rollback Migration")
try:
file = os.path.join(os.curdir, os.path.join("migrate/versions", (head_revision + "_.py")))
os.remove(file)
except FileNotFoundError:
pass
finally:
sys.exit()
except CommandError as E:
print(E)
print("Target Database not in sync")
print("Re-Run migration")
try:
engine.execute("drop table alembic_version")
purge("./migrate/versions", "\w+.py")
except exc.ProgrammingError:
pass
finally:
pass
return tables_
def test_bad_render(self):
env_file_fixture("""
context.configure(dialect_name='sqlite', template_args={"somearg":"somevalue"})
""")
script_file_fixture("""
<% z = x + y %>
""")
try:
command.revision(self.cfg, message="some rev")
except CommandError as ce:
m = re.match(
r"^Template rendering failed; see (.+?) "
"for a template-oriented", str(ce))
assert m, "Command error did not produce a file"
with open(m.group(1)) as handle:
contents = handle.read()
os.remove(m.group(1))
assert "<% z = x + y %>" in contents
def generate_migration(cfg, message='Initial Version'):
# Alembic has a bug with ARRAY type. This is a temporary workaround
command.revision(cfg, message='Initial Version', autogenerate=True)
result = []
pattern = '_'.join([chunk.lower() for chunk in message.split(' ')])
for root, dirs, files in os.walk('./alembic/versions'):
for name in files:
if pattern in name:
result.append(os.path.join(root, name))
with open(result[0], 'r') as file:
filedata = file.read()
# Replace the target string
filedata = filedata.replace('ARRAY(', 'ARRAY(sa.')
# Write the file out again
with open(result[0], 'w') as file:
file.write(filedata)
def run_revisions(alembic_directory: str, database_path: str = ""):
ini_path = os.path.join(alembic_directory, "alembic.ini")
script_location = os.path.join(alembic_directory, "alembic")
full_database_path = f'sqlite:///{database_path}'
alembic_cfg = Config(ini_path)
alembic_cfg.set_main_option('script_location', script_location)
alembic_cfg.set_main_option('sqlalchemy.url', full_database_path)
x = command.upgrade(alembic_cfg, 'head')
x = command.revision(alembic_cfg, autogenerate=True, message="content")
print
def run_alembic_cmd(self, opt):
'''
Logic for running different Alembic commands.
'''
from alembic import command as alembic_cmd
config = self.get_config()
# command consume any number of parameters but first is command name
cmd = opt.command.pop(0)
# init command needs to point to lux template, not alembic default
if cmd == 'init':
dirname = config.get_main_option('script_location')
# line 63 will be executed in:
# https://github.com/zzzeek/alembic/blob/master/alembic/command.py
# since we do not use any *.ini file, we simply silence error
# about referenced before assignment as it have no negative impact.
try:
alembic_cmd.init(config, dirname, template='lux')
except UnboundLocalError: # pragma nocover
pass
# merge required two revision name
elif cmd == 'merge':
if len(opt.command) != 2:
raise CommandError('Command %s required revisions id.' % cmd)
alembic_cmd.merge(config, opt.command, message=opt.msg,
branch_label=opt.branch)
elif cmd == 'revision':
alembic_cmd.revision(config, message=opt.msg,
branch_label=opt.branch)
# auto command is a shortcut for `revision --autogenerate`
elif cmd == 'auto':
alembic_cmd.revision(config, autogenerate=True, message=opt.msg,
branch_label=opt.branch)
# this commands required revision name, but do not take any message or
# branch labels
elif cmd in ('show', 'stamp', 'upgrade', 'downgrade'):
if len(opt.command) != 1:
raise CommandError('Command %s required revision id' % cmd)
getattr(alembic_cmd, cmd)(config, *opt.command)
else:
# execute commands without any additional params
getattr(alembic_cmd, cmd)(config)
def migrate(directory=None,
message=None,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None,
x_arg=None):
"""Alias for 'revision --autogenerate'"""
config = get_config(directory, opts=['autogenerate'], x_arg=x_arg)
command.revision(config,
message,
autogenerate=True,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
def revision(self, *_):
"""
Create a revision, happen current date to revision name.
:return: revision result.
"""
message = datetime.now().strftime("%Y-%m-%d_%H:%M")
result = command.revision(
self.config, message=message, autogenerate=True
)
return result
def test_multiple_dir_chooses_base(self):
command.revision(self.cfg,
message="x",
head="base",
version_path=os.path.join(_get_staging_directory(),
"model1"))
script2 = command.revision(self.cfg,
message="y",
head="base",
version_path=os.path.join(
_get_staging_directory(), "model2"))
script3 = command.revision(self.cfg,
message="y2",
head=script2.revision)
eq_(os.path.dirname(script3.path),
os.path.abspath(os.path.join(_get_staging_directory(), "model2")))
assert os.access(script3.path, os.F_OK)
def revision(directory=None,
message=None,
autogenerate=False,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None):
"""Create a new revision file."""
config = current_app.extensions['migrate'].migrate.get_config(directory)
command.revision(config,
message,
autogenerate=autogenerate,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
def test_tmpl_args_revision(self):
env_file_fixture(
"""
context.configure(dialect_name='sqlite', template_args={"somearg":"somevalue"})
"""
)
script_file_fixture(
"""
# somearg: ${somearg}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
"""
)
command.revision(self.cfg, message="some rev")
script = ScriptDirectory.from_config(self.cfg)
rev = script.get_revision("head")
with open(rev.path) as f:
text = f.read()
assert "somearg: somevalue" in text
def migrate(self,
directory=None,
message=None,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None,
**kwargs): # pragma: no cover
"""Alias for 'revision --autogenerate'"""
config = _get_config(directory)
command.revision(config,
message,
autogenerate=True,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
def simulate_autogenerate(config_path: str) -> t.List[tuple]:
"""Simulate the `alembic revision --autogenerate` command
and return a list of generated operations.
"""
config = Config(config_path)
revisions: t.List[MigrationScript] = []
def process_revision_directives(context, revision, directives):
nonlocal revisions
revisions = list(directives)
# Prevent actually generating a migration
directives[:] = []
revision(
config=config,
autogenerate=True,
process_revision_directives=process_revision_directives,
)
return list(
itertools.chain.from_iterable(op.as_diffs() for script in revisions
for op in script.upgrade_ops_list))
def _perform_makemigrations(directory=None,
message=None,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None,
x_arg=None):
"""Alias for 'revision --autogenerate'"""
config = current_app.extensions['migrate'].migrate.get_config(
directory, opts=['autogenerate'], x_arg=x_arg)
command.revision(config,
message,
autogenerate=True,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
def revision(args, logger, baseguess):
usable_modules, alembic_modules, alembic_config = alembic_setup(logger)
from alembic import command
if args.init:
if args.module not in alembic_modules:
print(
'{} isn\'t a configured module. You can create revisions on one of these: {}'
.format(args.module, ', '.join(alembic_modules)))
return
command.revision(
config=alembic_config,
message=args.message,
head='base',
branch_label=args.module,
autogenerate=args.autogenerate,
version_path=usable_modules[args.module].alembic['versions'])
else:
command.revision(config=alembic_config,
message=args.message,
autogenerate=args.autogenerate,
head='{}@head'.format(args.module))
def make_migration():
conn = sql.session()
alembic_cfg, script_, context = sql.get_alembic_ctx(conn)
message = console.string('Enter a message for the migration')
if not message:
print('Skipping migration.')
return
res = command.revision(message=message,
autogenerate=True,
config=alembic_cfg)
print('Generated Migration:', res)
print('Finished.')
def test_create_rev_autogen_db_not_up_to_date_multi_heads(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg)
rev3a = command.revision(self.cfg)
command.revision(self.cfg, head=rev2.revision, splice=True)
command.upgrade(self.cfg, "heads")
command.revision(self.cfg, head=rev3a.revision)
assert_raises_message(util.CommandError,
"Target database is not up to date.",
command.revision,
self.cfg,
autogenerate=True)
def test_create_rev_plain_db_not_up_to_date_multi_heads(self):
self._env_fixture()
command.revision(self.cfg)
rev2 = command.revision(self.cfg)
rev3a = command.revision(self.cfg)
command.revision(self.cfg, head=rev2.revision, splice=True)
command.upgrade(self.cfg, "heads")
command.revision(self.cfg, head=rev3a.revision)
assert_raises_message(
util.CommandError,
"Multiple heads are present; please specify the head revision "
"on which the new revision should be based, or perform a merge.",
command.revision, self.cfg)
def test_autogen(self):
self._write_metadata(
"""
import sqlalchemy as sa
m1 = sa.MetaData()
m2 = sa.MetaData()
m3 = sa.MetaData()
target_metadata = {"engine1": m1, "engine2": m2, "engine3": m3}
sa.Table('e1t1', m1, sa.Column('x', sa.Integer))
sa.Table('e2t1', m2, sa.Column('y', sa.Integer))
sa.Table('e3t1', m3, sa.Column('z', sa.Integer))
"""
)
rev = command.revision(
self.cfg, message="some message",
autogenerate=True
)
with mock.patch.object(rev.module, "op") as op_mock:
rev.module.upgrade_engine1()
eq_(
op_mock.mock_calls[-1],
mock.call.create_table('e1t1', mock.ANY)
)
rev.module.upgrade_engine2()
eq_(
op_mock.mock_calls[-1],
mock.call.create_table('e2t1', mock.ANY)
)
rev.module.upgrade_engine3()
eq_(
op_mock.mock_calls[-1],
mock.call.create_table('e3t1', mock.ANY)
)
rev.module.downgrade_engine1()
eq_(
op_mock.mock_calls[-1],
mock.call.drop_table('e1t1')
)
rev.module.downgrade_engine2()
eq_(
op_mock.mock_calls[-1],
mock.call.drop_table('e2t1')
)
rev.module.downgrade_engine3()
eq_(
op_mock.mock_calls[-1],
mock.call.drop_table('e3t1')
)
def cli_db_revision(message, autogenerate, sql, head, splice, branch_label,
version_path, rev_id):
"""
Create a new revision file.
"""
from modularapi.settings import get_setting
alembic_cfg = AlembicConfig("alembic.ini")
alembic_cfg.set_main_option("sqlalchemy.url", get_setting().PG_DNS)
alembic_cfg.set_main_option("script_location",
str(Path() / "db_migrations"))
command.revision(
config=alembic_cfg,
message=message,
autogenerate=autogenerate,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id,
)
def makemigrations(message):
if message is None:
click.echo(
click.style(
"Optinal: "
"Use -m <msg>, --message=<msg> to give a message string to this migrate script.",
fg='yellow'))
message = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
models = [m[:-3] for m in os.listdir(MODELS_DIR) if m.endswith(".py")]
for model in models:
print(f"Loading {model}... ", end="")
print(f"\r\t\t\t", end="")
try:
importlib.import_module(f'{MODELS_DIR}.{model}')
click.echo(click.style("loaded", fg='bright_green'))
except Exception as err:
click.echo(click.style("error", fg='bright_red'))
click.echo(click.style(f"↳ {err}", fg='bright_red'))
try:
cfg = get_alembic_conf()
alembic.revision(config=cfg,
message=message,
autogenerate=True,
sql=False,
head="head",
splice=False,
branch_label=None,
version_path=None,
rev_id=None)
except CommandError as err:
click.echo(click.style(str(err), fg='bright_red'))
if str(err) == "Target database is not up to date.":
click.echo(
click.style("run \"python bot.py migrate\"", fg='yellow'))
def revision(config, message: Optional[str], autogenerate: bool, sql: bool,
head: str, splice: bool, branch_label: Optional[str],
version_path: Optional[str], rev_id: Optional[str]):
"""Create a new revision file."""
bot = Bot(config)
directory = os.path.join('yui', 'models', 'migrations')
c = Config(os.path.join(directory, 'alembic.ini'))
c.set_main_option('script_location', directory)
c.set_main_option('sqlalchemy.url', bot.config.DATABASE_URL)
c.attributes['Base'] = bot.orm_base
command.revision(c,
message,
autogenerate=autogenerate,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
def check_no_pending_migrations():
class EmtpyException(Exception):
pass
class OkException(Exception):
pass
def raise_if_pending_migrations(migration_context, rev,
generated_revisions):
if generated_revisions[0].upgrade_ops.is_empty():
raise OkException()
else:
raise EmtpyException(
f'There are changes in the models not reflected in the alembic'
f' scripts: {generated_revisions[0].upgrade_ops.as_diffs()}')
with contextlib.suppress(OkException):
command.revision(
alembic_cfg,
autogenerate=True,
process_revision_directives=raise_if_pending_migrations,
)
def revision(config,
message=None,
autogenerate=False,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None):
"""Create a new revision file."""
if alembic_version >= (0, 7, 0):
command.revision(config,
message,
autogenerate=autogenerate,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
else:
command.revision(config, message, autogenerate=autogenerate, sql=sql)
def migrate(directory=None,
message=None,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None):
"""Alias for 'revision --autogenerate'"""
config = _get_config(directory)
if alembic_version >= (0, 7, 0):
command.revision(config,
message,
autogenerate=True,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
else:
command.revision(config, message, autogenerate=True, sql=sql)
def migrate(config,
message=None,
sql=False,
head='head',
splice=False,
branch_label=None,
version_path=None,
rev_id=None):
"""Alias for 'revision --autogenerate'"""
setattr(config.cmd_opts, 'autogenerate', True)
if alembic_version >= (0, 7, 0):
command.revision(config,
message,
autogenerate=True,
sql=sql,
head=head,
splice=splice,
branch_label=branch_label,
version_path=version_path,
rev_id=rev_id)
else:
command.revision(config, message, autogenerate=True, sql=sql)
