Flask-Migrate-1.7.0/0000755060175106010010000000000012640141306014347 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/flask_migrate/0000755060175106010010000000000012640141305017156 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/flask_migrate/templates/0000755060175106010010000000000012640141305021154 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/flask_migrate/templates/flask/0000755060175106010010000000000012640141305022254 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/flask_migrate/templates/flask/alembic.ini.mako0000644060175106010010000000140212556326504025310 0ustar miguelNone00000000000000# A generic, single database configuration. [alembic] # template used to generate migration files # file_template = %%(rev)s_%%(slug)s # set to 'true' to run the environment during # the 'revision' command, regardless of autogenerate # revision_environment = false # Logging configuration [loggers] keys = root,sqlalchemy,alembic [handlers] keys = console [formatters] keys = generic [logger_root] level = WARN handlers = console qualname = [logger_sqlalchemy] level = WARN handlers = qualname = sqlalchemy.engine [logger_alembic] level = INFO handlers = qualname = alembic [handler_console] class = StreamHandler args = (sys.stderr,) level = NOTSET formatter = generic [formatter_generic] format = %(levelname)-5.5s [%(name)s] %(message)s datefmt = %H:%M:%S Flask-Migrate-1.7.0/flask_migrate/templates/flask/env.py0000755060175106010010000000550312566402306023434 0ustar miguelNone00000000000000from __future__ import with_statement from alembic import context from sqlalchemy import engine_from_config, pool from logging.config import fileConfig import logging # this is the Alembic Config object, which provides # access to the values within the .ini file in use. config = context.config # Interpret the config file for Python logging. # This line sets up loggers basically. fileConfig(config.config_file_name) logger = logging.getLogger('alembic.env') # add your model's MetaData object here # for 'autogenerate' support # from myapp import mymodel # target_metadata = mymodel.Base.metadata from flask import current_app config.set_main_option('sqlalchemy.url', current_app.config.get('SQLALCHEMY_DATABASE_URI')) target_metadata = current_app.extensions['migrate'].db.metadata # other values from the config, defined by the needs of env.py, # can be acquired: # my_important_option = config.get_main_option("my_important_option") # ... etc. def run_migrations_offline(): """Run migrations in 'offline' mode. This configures the context with just a URL and not an Engine, though an Engine is acceptable here as well. By skipping the Engine creation we don't even need a DBAPI to be available. Calls to context.execute() here emit the given string to the script output. """ url = config.get_main_option("sqlalchemy.url") context.configure(url=url) with context.begin_transaction(): context.run_migrations() def run_migrations_online(): """Run migrations in 'online' mode. In this scenario we need to create an Engine and associate a connection with the context. """ # this callback is used to prevent an auto-migration from being generated # when there are no changes to the schema # reference: http://alembic.readthedocs.org/en/latest/cookbook.html def process_revision_directives(context, revision, directives): if getattr(config.cmd_opts, 'autogenerate', False): script = directives[0] if script.upgrade_ops.is_empty(): directives[:] = [] logger.info('No changes in schema detected.') engine = engine_from_config(config.get_section(config.config_ini_section), prefix='sqlalchemy.', poolclass=pool.NullPool) connection = engine.connect() context.configure(connection=connection, target_metadata=target_metadata, process_revision_directives=process_revision_directives, **current_app.extensions['migrate'].configure_args) try: with context.begin_transaction(): context.run_migrations() finally: connection.close() if context.is_offline_mode(): run_migrations_offline() else: run_migrations_online() Flask-Migrate-1.7.0/flask_migrate/templates/flask/README0000755060175106010010000000004612556326504023153 0ustar miguelNone00000000000000Generic single-database configuration.Flask-Migrate-1.7.0/flask_migrate/templates/flask/script.py.mako0000755060175106010010000000063412556326504025102 0ustar miguelNone00000000000000"""${message} Revision ID: ${up_revision} Revises: ${down_revision} Create Date: ${create_date} """ # revision identifiers, used by Alembic. revision = ${repr(up_revision)} down_revision = ${repr(down_revision)} from alembic import op import sqlalchemy as sa ${imports if imports else ""} def upgrade(): ${upgrades if upgrades else "pass"} def downgrade(): ${downgrades if downgrades else "pass"} Flask-Migrate-1.7.0/flask_migrate/templates/flask-multidb/0000755060175106010010000000000012640141306023713 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/flask_migrate/templates/flask-multidb/alembic.ini.mako0000644060175106010010000000140212557213210026734 0ustar miguelNone00000000000000# A generic, single database configuration. [alembic] # template used to generate migration files # file_template = %%(rev)s_%%(slug)s # set to 'true' to run the environment during # the 'revision' command, regardless of autogenerate # revision_environment = false # Logging configuration [loggers] keys = root,sqlalchemy,alembic [handlers] keys = console [formatters] keys = generic [logger_root] level = WARN handlers = console qualname = [logger_sqlalchemy] level = WARN handlers = qualname = sqlalchemy.engine [logger_alembic] level = INFO handlers = qualname = alembic [handler_console] class = StreamHandler args = (sys.stderr,) level = NOTSET formatter = generic [formatter_generic] format = %(levelname)-5.5s [%(name)s] %(message)s datefmt = %H:%M:%S Flask-Migrate-1.7.0/flask_migrate/templates/flask-multidb/env.py0000755060175106010010000001251012566537332025076 0ustar miguelNone00000000000000from __future__ import with_statement from alembic import context from sqlalchemy import engine_from_config, pool, MetaData from logging.config import fileConfig import logging USE_TWOPHASE = False # this is the Alembic Config object, which provides # access to the values within the .ini file in use. config = context.config # Interpret the config file for Python logging. # This line sets up loggers basically. fileConfig(config.config_file_name) logger = logging.getLogger('alembic.env') # add your model's MetaData object here # for 'autogenerate' support # from myapp import mymodel # target_metadata = mymodel.Base.metadata from flask import current_app config.set_main_option('sqlalchemy.url', current_app.config.get('SQLALCHEMY_DATABASE_URI')) bind_names = [] for name, url in current_app.config.get("SQLALCHEMY_BINDS").items(): context.config.set_section_option(name, "sqlalchemy.url", url) bind_names.append(name) target_metadata = current_app.extensions['migrate'].db.metadata # other values from the config, defined by the needs of env.py, # can be acquired: # my_important_option = config.get_main_option("my_important_option") # ... etc. def get_metadata(bind): """Return the metadata for a bind.""" if bind == '': bind = None m = MetaData() for t in target_metadata.tables.values(): if t.info.get('bind_key') == bind: t.tometadata(m) return m def run_migrations_offline(): """Run migrations in 'offline' mode. This configures the context with just a URL and not an Engine, though an Engine is acceptable here as well. By skipping the Engine creation we don't even need a DBAPI to be available. Calls to context.execute() here emit the given string to the script output. """ # for the --sql use case, run migrations for each URL into # individual files. engines = {'': {'url': context.config.get_main_option('sqlalchemy.url')}} for name in bind_names: engines[name] = rec = {} rec['url'] = context.config.get_section_option(name, "sqlalchemy.url") for name, rec in engines.items(): logger.info("Migrating database %s" % (name or '')) file_ = "%s.sql" % name logger.info("Writing output to %s" % file_) with open(file_, 'w') as buffer: context.configure(url=rec['url'], output_buffer=buffer, target_metadata=get_metadata(name), literal_binds=True) with context.begin_transaction(): context.run_migrations(engine_name=name) def run_migrations_online(): """Run migrations in 'online' mode. In this scenario we need to create an Engine and associate a connection with the context. """ # this callback is used to prevent an auto-migration from being generated # when there are no changes to the schema # reference: http://alembic.readthedocs.org/en/latest/cookbook.html def process_revision_directives(context, revision, directives): if getattr(config.cmd_opts, 'autogenerate', False): script = directives[0] if len(script.upgrade_ops_list) >= len(bind_names) + 1: empty = True for upgrade_ops in script.upgrade_ops_list: if not upgrade_ops.is_empty(): empty = False if empty: directives[:] = [] logger.info('No changes in schema detected.') # for the direct-to-DB use case, start a transaction on all # engines, then run all migrations, then commit all transactions. engines = {'': {'engine': engine_from_config( config.get_section(config.config_ini_section), prefix='sqlalchemy.', poolclass=pool.NullPool)}} for name in bind_names: engines[name] = rec = {} rec['engine'] = engine_from_config( context.config.get_section(name), prefix='sqlalchemy.', poolclass=pool.NullPool) for name, rec in engines.items(): engine = rec['engine'] rec['connection'] = conn = engine.connect() if USE_TWOPHASE: rec['transaction'] = conn.begin_twophase() else: rec['transaction'] = conn.begin() try: for name, rec in engines.items(): logger.info("Migrating database %s" % (name or '')) context.configure( connection=rec['connection'], upgrade_token="%s_upgrades" % name, downgrade_token="%s_downgrades" % name, target_metadata=get_metadata(name), process_revision_directives=process_revision_directives, **current_app.extensions['migrate'].configure_args ) context.run_migrations(engine_name=name) if USE_TWOPHASE: for rec in engines.values(): rec['transaction'].prepare() for rec in engines.values(): rec['transaction'].commit() except: for rec in engines.values(): rec['transaction'].rollback() raise finally: for rec in engines.values(): rec['connection'].close() if context.is_offline_mode(): run_migrations_offline() else: run_migrations_online() Flask-Migrate-1.7.0/flask_migrate/templates/flask-multidb/README0000755060175106010010000000004612557213177024613 0ustar miguelNone00000000000000Generic single-database configuration.Flask-Migrate-1.7.0/flask_migrate/templates/flask-multidb/script.py.mako0000755060175106010010000000170512557214037026536 0ustar miguelNone00000000000000<%! import re %>"""${message} Revision ID: ${up_revision} Revises: ${down_revision | comma,n} Create Date: ${create_date} """ # revision identifiers, used by Alembic. revision = ${repr(up_revision)} down_revision = ${repr(down_revision)} branch_labels = ${repr(branch_labels)} depends_on = ${repr(depends_on)} from alembic import op import sqlalchemy as sa ${imports if imports else ""} def upgrade(engine_name): globals()["upgrade_%s" % engine_name]() def downgrade(engine_name): globals()["downgrade_%s" % engine_name]() <% from flask import current_app db_names = [''] + list(current_app.config.get("SQLALCHEMY_BINDS").keys()) %> ## generate an "upgrade_() / downgrade_()" function ## for each database name in the ini file. % for db_name in db_names: def upgrade_${db_name}(): ${context.get("%s_upgrades" % db_name, "pass")} def downgrade_${db_name}(): ${context.get("%s_downgrades" % db_name, "pass")} % endfor Flask-Migrate-1.7.0/flask_migrate/__init__.py0000755060175106010010000004167612636200724021316 0ustar miguelNone00000000000000import os import argparse from flask import current_app from flask.ext.script import Manager from alembic import __version__ as __alembic_version__ from alembic.config import Config as AlembicConfig from alembic import command alembic_version = tuple([int(v) for v in __alembic_version__.split('.')[0:3]]) class _MigrateConfig(object): def __init__(self, migrate, db, **kwargs): self.migrate = migrate self.db = db self.directory = migrate.directory self.configure_args = kwargs @property def metadata(self): """ Backwards compatibility, in old releases app.extensions['migrate'] was set to db, and env.py accessed app.extensions['migrate'].metadata """ return self.db.metadata class Config(AlembicConfig): def get_template_directory(self): package_dir = os.path.abspath(os.path.dirname(__file__)) return os.path.join(package_dir, 'templates') class Migrate(object): def __init__(self, app=None, db=None, directory='migrations', **kwargs): self.configure_callbacks = [] self.directory = directory if app is not None and db is not None: self.init_app(app, db, directory, **kwargs) def init_app(self, app, db, directory=None, **kwargs): self.directory = directory or self.directory if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['migrate'] = _MigrateConfig(self, db, **kwargs) def configure(self, f): self.configure_callbacks.append(f) return f def call_configure_callbacks(self, config): for f in self.configure_callbacks: config = f(config) return config def get_config(self, directory, x_arg=None, opts=None): if directory is None: directory = self.directory config = Config(os.path.join(directory, 'alembic.ini')) config.set_main_option('script_location', directory) if config.cmd_opts is None: config.cmd_opts = argparse.Namespace() for opt in opts or []: setattr(config.cmd_opts, opt, True) if x_arg is not None: if not getattr(config.cmd_opts, 'x', None): setattr(config.cmd_opts, 'x', [x_arg]) else: config.cmd_opts.x.append(x_arg) return self.call_configure_callbacks(config) MigrateCommand = Manager(usage='Perform database migrations') @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) @MigrateCommand.option('--multidb', dest='multidb', action='store_true', default=False, help=("Multiple databases migraton (default is " "False)")) def init(directory=None, multidb=False): """Generates a new migration""" if directory is None: directory = current_app.extensions['migrate'].directory config = Config() config.set_main_option('script_location', directory) config.config_file_name = os.path.join(directory, 'alembic.ini') config = current_app.extensions['migrate'].\ migrate.call_configure_callbacks(config) if multidb: command.init(config, directory, 'flask-multidb') else: command.init(config, directory, 'flask') @MigrateCommand.option('--rev-id', dest='rev_id', default=None, help=('Specify a hardcoded revision id instead of ' 'generating one')) @MigrateCommand.option('--version-path', dest='version_path', default=None, help=('Specify specific path from config for version ' 'file')) @MigrateCommand.option('--branch-label', dest='branch_label', default=None, help=('Specify a branch label to apply to the new ' 'revision')) @MigrateCommand.option('--splice', dest='splice', action='store_true', default=False, help=('Allow a non-head revision as the "head" to ' 'splice onto')) @MigrateCommand.option('--head', dest='head', default='head', help=('Specify head revision or @head to ' 'base new revision on')) @MigrateCommand.option('--sql', dest='sql', action='store_true', default=False, help=("Don't emit SQL to database - dump to standard " "output instead")) @MigrateCommand.option('--autogenerate', dest='autogenerate', action='store_true', default=False, help=('Populate revision script with andidate migration ' 'operatons, based on comparison of database to ' 'model')) @MigrateCommand.option('-m', '--message', dest='message', default=None) @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) 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) @MigrateCommand.option('--rev-id', dest='rev_id', default=None, help=('Specify a hardcoded revision id instead of ' 'generating one')) @MigrateCommand.option('--version-path', dest='version_path', default=None, help=('Specify specific path from config for version ' 'file')) @MigrateCommand.option('--branch-label', dest='branch_label', default=None, help=('Specify a branch label to apply to the new ' 'revision')) @MigrateCommand.option('--splice', dest='splice', action='store_true', default=False, help=('Allow a non-head revision as the "head" to ' 'splice onto')) @MigrateCommand.option('--head', dest='head', default='head', help=('Specify head revision or @head to ' 'base new revision on')) @MigrateCommand.option('--sql', dest='sql', action='store_true', default=False, help=("Don't emit SQL to database - dump to standard " "output instead")) @MigrateCommand.option('-m', '--message', dest='message', default=None) @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) 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 = current_app.extensions['migrate'].migrate.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) @MigrateCommand.option('revision', nargs='?', default='head', help="revision identifier") @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def edit(revision='current', directory=None): """Edit current revision.""" if alembic_version >= (0, 8, 0): config = current_app.extensions['migrate'].migrate.get_config( directory) command.edit(config, revision) else: raise RuntimeError('Alembic 0.8.0 or greater is required') @MigrateCommand.option('--rev-id', dest='rev_id', default=None, help=('Specify a hardcoded revision id instead of ' 'generating one')) @MigrateCommand.option('--branch-label', dest='branch_label', default=None, help=('Specify a branch label to apply to the new ' 'revision')) @MigrateCommand.option('-m', '--message', dest='message', default=None) @MigrateCommand.option('revisions', nargs='+', help='one or more revisions, or "heads" for all heads') @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def merge(directory=None, revisions='', message=None, branch_label=None, rev_id=None): """Merge two revisions together. Creates a new migration file""" if alembic_version >= (0, 7, 0): config = current_app.extensions['migrate'].migrate.get_config( directory) command.merge(config, revisions, message=message, branch_label=branch_label, rev_id=rev_id) else: raise RuntimeError('Alembic 0.7.0 or greater is required') @MigrateCommand.option('--tag', dest='tag', default=None, help=("Arbitrary 'tag' name - can be used by custom " "env.py scripts")) @MigrateCommand.option('--sql', dest='sql', action='store_true', default=False, help=("Don't emit SQL to database - dump to standard " "output instead")) @MigrateCommand.option('revision', nargs='?', default='head', help="revision identifier") @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) @MigrateCommand.option('-x', '--x-arg', dest='x_arg', default=None, help=("Additional arguments consumed by " "custom env.py scripts")) def upgrade(directory=None, revision='head', sql=False, tag=None, x_arg=None): """Upgrade to a later version""" config = current_app.extensions['migrate'].migrate.get_config(directory, x_arg=x_arg) command.upgrade(config, revision, sql=sql, tag=tag) @MigrateCommand.option('--tag', dest='tag', default=None, help=("Arbitrary 'tag' name - can be used by custom " "env.py scripts")) @MigrateCommand.option('--sql', dest='sql', action='store_true', default=False, help=("Don't emit SQL to database - dump to standard " "output instead")) @MigrateCommand.option('revision', nargs='?', default="-1", help="revision identifier") @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) @MigrateCommand.option('-x', '--x-arg', dest='x_arg', default=None, help=("Additional arguments consumed by " "custom env.py scripts")) def downgrade(directory=None, revision='-1', sql=False, tag=None, x_arg=None): """Revert to a previous version""" config = current_app.extensions['migrate'].migrate.get_config(directory, x_arg=x_arg) if sql and revision == '-1': revision = 'head:-1' command.downgrade(config, revision, sql=sql, tag=tag) @MigrateCommand.option('revision', nargs='?', default="head", help="revision identifier") @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def show(directory=None, revision='head'): """Show the revision denoted by the given symbol.""" if alembic_version >= (0, 7, 0): config = current_app.extensions['migrate'].migrate.get_config( directory) command.show(config, revision) else: raise RuntimeError('Alembic 0.7.0 or greater is required') @MigrateCommand.option('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Use more verbose output') @MigrateCommand.option('-r', '--rev-range', dest='rev_range', default=None, help='Specify a revision range; format is [start]:[end]') @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def history(directory=None, rev_range=None, verbose=False): """List changeset scripts in chronological order.""" config = current_app.extensions['migrate'].migrate.get_config(directory) if alembic_version >= (0, 7, 0): command.history(config, rev_range, verbose=verbose) else: command.history(config, rev_range) @MigrateCommand.option('--resolve-dependencies', dest='resolve_dependencies', action='store_true', default=False, help='Treat dependency versions as down revisions') @MigrateCommand.option('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Use more verbose output') @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def heads(directory=None, verbose=False, resolve_dependencies=False): """Show current available heads in the script directory""" if alembic_version >= (0, 7, 0): config = current_app.extensions['migrate'].migrate.get_config( directory) command.heads(config, verbose=verbose, resolve_dependencies=resolve_dependencies) else: raise RuntimeError('Alembic 0.7.0 or greater is required') @MigrateCommand.option('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Use more verbose output') @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def branches(directory=None, verbose=False): """Show current branch points""" config = current_app.extensions['migrate'].migrate.get_config(directory) if alembic_version >= (0, 7, 0): command.branches(config, verbose=verbose) else: command.branches(config) @MigrateCommand.option('--head-only', dest='head_only', action='store_true', default=False, help='Deprecated. Use --verbose for additional output') @MigrateCommand.option('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Use more verbose output') @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def current(directory=None, verbose=False, head_only=False): """Display the current revision for each database.""" config = current_app.extensions['migrate'].migrate.get_config(directory) if alembic_version >= (0, 7, 0): command.current(config, verbose=verbose, head_only=head_only) else: command.current(config) @MigrateCommand.option('--tag', dest='tag', default=None, help=("Arbitrary 'tag' name - can be used by custom " "env.py scripts")) @MigrateCommand.option('--sql', dest='sql', action='store_true', default=False, help=("Don't emit SQL to database - dump to standard " "output instead")) @MigrateCommand.option('revision', default=None, help="revision identifier") @MigrateCommand.option('-d', '--directory', dest='directory', default=None, help=("migration script directory (default is " "'migrations')")) def stamp(directory=None, revision='head', sql=False, tag=None): """'stamp' the revision table with the given revision; don't run any migrations""" config = current_app.extensions['migrate'].migrate.get_config(directory) command.stamp(config, revision, sql=sql, tag=tag) Flask-Migrate-1.7.0/Flask_Migrate.egg-info/0000755060175106010010000000000012640141305020550 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/Flask_Migrate.egg-info/dependency_links.txt0000644060175106010010000000000112640141303024614 0ustar miguelNone00000000000000 Flask-Migrate-1.7.0/Flask_Migrate.egg-info/not-zip-safe0000644060175106010010000000000212556327022023007 0ustar miguelNone00000000000000 Flask-Migrate-1.7.0/Flask_Migrate.egg-info/PKG-INFO0000644060175106010010000000152112640141303021642 0ustar miguelNone00000000000000Metadata-Version: 1.1 Name: Flask-Migrate Version: 1.7.0 Summary: SQLAlchemy database migrations for Flask applications using Alembic Home-page: http://github.com/miguelgrinberg/flask-migrate/ Author: Miguel Grinberg Author-email: miguelgrinberg50@gmail.com License: MIT Description: Flask-Migrate -------------- SQLAlchemy database migrations for Flask applications using Alembic. Platform: any Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content Classifier: Topic :: Software Development :: Libraries :: Python Modules Flask-Migrate-1.7.0/Flask_Migrate.egg-info/requires.txt0000644060175106010010000000010012640141303023135 0ustar miguelNone00000000000000Flask>=0.9 Flask-SQLAlchemy>=1.0 alembic>=0.6 Flask-Script>=0.6 Flask-Migrate-1.7.0/Flask_Migrate.egg-info/SOURCES.txt0000644060175106010010000000204012640141305022430 0ustar miguelNone00000000000000LICENSE MANIFEST.in README.md setup.py Flask_Migrate.egg-info/PKG-INFO Flask_Migrate.egg-info/SOURCES.txt Flask_Migrate.egg-info/dependency_links.txt Flask_Migrate.egg-info/not-zip-safe Flask_Migrate.egg-info/requires.txt Flask_Migrate.egg-info/top_level.txt flask_migrate/__init__.py flask_migrate/templates/flask/README flask_migrate/templates/flask/alembic.ini.mako flask_migrate/templates/flask/env.py flask_migrate/templates/flask/script.py.mako flask_migrate/templates/flask-multidb/README flask_migrate/templates/flask-multidb/alembic.ini.mako flask_migrate/templates/flask-multidb/env.py flask_migrate/templates/flask-multidb/script.py.mako tests/.sql tests/__init__.py tests/__init__.pyc tests/app.db tests/app.py tests/app.pyc tests/app_compare_type1.py tests/app_compare_type1.pyc tests/app_compare_type2.py tests/app_compare_type2.pyc tests/app_custom_directory.py tests/app_custom_directory.pyc tests/app_multidb.py tests/app_multidb.pyc tests/test_migrate.py tests/test_migrate.pyc tests/test_multidb_migrate.py tests/test_multidb_migrate.pycFlask-Migrate-1.7.0/Flask_Migrate.egg-info/top_level.txt0000644060175106010010000000001612640141303023275 0ustar miguelNone00000000000000flask_migrate Flask-Migrate-1.7.0/LICENSE0000644060175106010010000000207212556326504015370 0ustar miguelNone00000000000000The MIT License (MIT) Copyright (c) 2013 Miguel Grinberg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Flask-Migrate-1.7.0/MANIFEST.in0000644060175106010010000000015512557213177016123 0ustar miguelNone00000000000000include README.md LICENSE flask_migrate/templates/flask/* \ flask_migrate/templates/flask-multidb/* tests/* Flask-Migrate-1.7.0/PKG-INFO0000644060175106010010000000152112640141306015443 0ustar miguelNone00000000000000Metadata-Version: 1.1 Name: Flask-Migrate Version: 1.7.0 Summary: SQLAlchemy database migrations for Flask applications using Alembic Home-page: http://github.com/miguelgrinberg/flask-migrate/ Author: Miguel Grinberg Author-email: miguelgrinberg50@gmail.com License: MIT Description: Flask-Migrate -------------- SQLAlchemy database migrations for Flask applications using Alembic. Platform: any Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content Classifier: Topic :: Software Development :: Libraries :: Python Modules Flask-Migrate-1.7.0/README.md0000644060175106010010000000437112556326504015646 0ustar miguelNone00000000000000Flask-Migrate ============= [![Build Status](https://travis-ci.org/miguelgrinberg/Flask-Migrate.png?branch=master)](https://travis-ci.org/miguelgrinberg/Flask-Migrate) Flask-Migrate is an extension that handles SQLAlchemy database migrations for Flask applications using Alembic. The database operations are provided as command line arguments for Flask-Script. Installation ------------ Install Flask-Migrate with `pip`: pip install Flask-Migrate Example ------- This is an example application that handles database migrations through Flask-Migrate: ```python from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.script import Manager from flask.ext.migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app) migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128)) if __name__ == '__main__': manager.run() ``` With the above application you can create the database or enable migrations if the database already exists with the following command: $ python app.py db init This will add a `migrations` folder to your application. The contents of this folder need to be added to version control along with your other source files. You can then generate an initial migration: $ python app.py db migrate The migration script needs to be reviewed and edited, as Alembic currently does not detect every change you make to your models. In particular, Alembic is currently unable to detect indexes. Once finalized, the migration script also needs to be added to version control. Then you can apply the migration to the database: $ python app.py db upgrade Then each time the database models change repeat the `migrate` and `upgrade` commands. To sync the database in another system just refresh the `migrations` folder from source control and run the `upgrade` command. To see all the commands that are available run this command: $ python app.py db --help Resources --------- - [Documentation](http://pythonhosted.org/Flask-Migrate) - [pypi](https://pypi.python.org/pypi/Flask-Migrate) Flask-Migrate-1.7.0/setup.cfg0000644060175106010010000000007312640141306016170 0ustar miguelNone00000000000000[egg_info] tag_svn_revision = 0 tag_date = 0 tag_build = Flask-Migrate-1.7.0/setup.py0000644060175106010010000000223212640141065016062 0ustar miguelNone00000000000000""" Flask-Migrate -------------- SQLAlchemy database migrations for Flask applications using Alembic. """ from setuptools import setup setup( name='Flask-Migrate', version='1.7.0', url='http://github.com/miguelgrinberg/flask-migrate/', license='MIT', author='Miguel Grinberg', author_email='miguelgrinberg50@gmail.com', description=('SQLAlchemy database migrations for Flask applications ' 'using Alembic'), long_description=__doc__, packages=['flask_migrate'], zip_safe=False, include_package_data=True, platforms='any', install_requires=[ 'Flask>=0.9', 'Flask-SQLAlchemy>=1.0', 'alembic>=0.6', 'Flask-Script>=0.6' ], test_suite="tests", classifiers=[ 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Topic :: Internet :: WWW/HTTP :: Dynamic Content', 'Topic :: Software Development :: Libraries :: Python Modules' ] ) Flask-Migrate-1.7.0/tests/0000755060175106010010000000000012640141306015511 5ustar miguelNone00000000000000Flask-Migrate-1.7.0/tests/.sql0000644060175106010010000000000012557214266016314 0ustar miguelNone00000000000000Flask-Migrate-1.7.0/tests/app.db0000755060175106010010000000400012636201663016605 0ustar miguelNone00000000000000SQLite format 3@ -æ ‘‘m++tablealembic_versionalembic_versionCREATE TABLE alembic_version ( version_num VARCHAR(32) NOT NULL ) Flask-Migrate-1.7.0/tests/app.py0000755060175106010010000000100612636201761016652 0ustar miguelNone00000000000000#!/bin/env python from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_script import Manager from flask_migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app) migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128)) if __name__ == '__main__': manager.run() Flask-Migrate-1.7.0/tests/app.pyc0000644060175106010010000000177612566537342017041 0ustar miguelNone00000000000000ó ~ûÙUc@sÌddlmZddlmZddlmZddlmZmZee ƒZ de j ds     Flask-Migrate-1.7.0/tests/app_compare_type1.py0000755060175106010010000000100712556326504021507 0ustar miguelNone00000000000000from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_script import Manager from flask_migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app) migrate = Migrate(app, db, compare_type=True) manager = Manager(app) manager.add_command('db', MigrateCommand) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128)) if __name__ == '__main__': manager.run() Flask-Migrate-1.7.0/tests/app_compare_type1.pyc0000644060175106010010000000206612557202656021657 0ustar miguelNone00000000000000ó D­¹Uc@sÒddlmZddlmZddlmZddlmZmZee ƒZ de j ds     Flask-Migrate-1.7.0/tests/app_compare_type2.py0000755060175106010010000000100612556326504021507 0ustar miguelNone00000000000000from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_script import Manager from flask_migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app) migrate = Migrate(app, db, compare_type=True) manager = Manager(app) manager.add_command('db', MigrateCommand) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(10)) if __name__ == '__main__': manager.run() Flask-Migrate-1.7.0/tests/app_compare_type2.pyc0000644060175106010010000000206612557202656021660 0ustar miguelNone00000000000000ó D­¹Uc@sÒddlmZddlmZddlmZddlmZmZee ƒZ de j ds     Flask-Migrate-1.7.0/tests/app_custom_directory.py0000755060175106010010000000103612556326504022337 0ustar miguelNone00000000000000from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_script import Manager from flask_migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' db = SQLAlchemy(app) migrate = Migrate(app, db, directory='temp_folder/temp_migrations') manager = Manager(app) manager.add_command('db', MigrateCommand) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128)) if __name__ == '__main__': manager.run() Flask-Migrate-1.7.0/tests/app_custom_directory.pyc0000644060175106010010000000212412557202656022500 0ustar miguelNone00000000000000ó D­¹Uc@sÒddlmZddlmZddlmZddlmZmZee ƒZ de j ds     Flask-Migrate-1.7.0/tests/app_multidb.py0000755060175106010010000000132612566537311020404 0ustar miguelNone00000000000000#!/bin/env python from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_script import Manager from flask_migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app1.db' app.config['SQLALCHEMY_BINDS'] = { "db1": "sqlite:///app2.db", } db = SQLAlchemy(app) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128)) class Group(db.Model): __bind_key__ = 'db1' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(128)) migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) if __name__ == '__main__': manager.run() Flask-Migrate-1.7.0/tests/app_multidb.pyc0000644060175106010010000000263212566537343020552 0ustar miguelNone00000000000000ó ɾÚUc@sùddlmZddlmZddlmZddlmZmZee ƒZ de j deZdZejejdeƒZejejdƒƒZ RS(RR i€( R R t __bind_key__R R RRRRR(((sC/home/miguel/Documents/dev/flask/flask-migrate/tests/app_multidb.pyRsR t__main__N(tflaskRtflask_sqlalchemyRt flask_scriptRt flask_migrateRRR tapptconfigR tModelRRtmigratetmanagert add_commandtrun(((sC/home/miguel/Documents/dev/flask/flask-migrate/tests/app_multidb.pyts     Flask-Migrate-1.7.0/tests/test_migrate.py0000755060175106010010000000534512557205451020575 0ustar miguelNone00000000000000import os import shutil import unittest import subprocess import shlex def run_cmd(cmd): """Run a command and return a tuple with (stdout, stderr, exit_code)""" process = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = process.communicate() return stdout, stderr, process.wait() class TestMigrate(unittest.TestCase): def setUp(self): os.chdir(os.path.split(os.path.abspath(__file__))[0]) try: os.remove('app.db') except OSError: pass try: shutil.rmtree('migrations') except OSError: pass try: shutil.rmtree('temp_folder') except OSError: pass def tearDown(self): try: os.remove('app.db') except OSError: pass try: shutil.rmtree('migrations') except OSError: pass try: shutil.rmtree('temp_folder') except OSError: pass def test_alembic_version(self): from flask_migrate import alembic_version self.assertEqual(len(alembic_version), 3) for v in alembic_version: self.assertTrue(isinstance(v, int)) def test_migrate_upgrade(self): (o, e, s) = run_cmd('python app.py db init') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app.py db migrate') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app.py db upgrade') self.assertTrue(s == 0) from .app import db, User db.session.add(User(name='test')) db.session.commit() def test_custom_directory(self): (o, e, s) = run_cmd('python app_custom_directory.py db init') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_custom_directory.py db migrate') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_custom_directory.py db upgrade') self.assertTrue(s == 0) from .app_custom_directory import db, User db.session.add(User(name='test')) db.session.commit() def test_compare_type(self): (o, e, s) = run_cmd('python app_compare_type1.py db init') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_compare_type1.py db migrate') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_compare_type1.py db upgrade') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_compare_type2.py db migrate') self.assertTrue(s == 0) self.assertTrue(b'Detected type change from VARCHAR(length=128) ' b'to String(length=10)' in e) if __name__ == '__main__': unittest.main() Flask-Migrate-1.7.0/tests/test_migrate.pyc0000644060175106010010000001001712557205464020731 0ustar miguelNone00000000000000ó ) ½Uc@s{ddlZddlZddlZddlZddlZd„Zdejfd„ƒYZedkrwej ƒndS(iÿÿÿÿNcCsOtjtj|ƒdtjdtjƒ}|jƒ\}}|||jƒfS(sARun a command and return a tuple with (stdout, stderr, exit_code)tstdouttstderr(t subprocesstPopentshlextsplittPIPEt communicatetwait(tcmdtprocessRR((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pytrun_cmds t TestMigratecBs>eZd„Zd„Zd„Zd„Zd„Zd„ZRS(cCsœtjtjjtjjtƒƒdƒytjdƒWntk rMnXytj dƒWntk rrnXytj dƒWntk r—nXdS(Nisapp.dbt migrationst temp_folder( tostchdirtpathRtabspatht__file__tremovetOSErrortshutiltrmtree(tself((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pytsetUps)   cCssytjdƒWntk r$nXytjdƒWntk rInXytjdƒWntk rnnXdS(Nsapp.dbR R(RRRRR(R((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyttearDown s   cCsQddlm}|jt|ƒdƒx$|D]}|jt|tƒƒq-WdS(Niÿÿÿÿ(talembic_versioni(t flask_migrateRt assertEqualtlent assertTruet isinstancetint(RRtv((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyttest_alembic_version.s cCs¸tdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒddlm}m}|jj|ddƒƒ|jjƒdS( Nspython app.py db initispython app.py db migratespython app.py db upgradei(tdbtUsertnamettest(R RtappR$R%tsessiontaddtcommit(RtotetsR$R%((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyttest_migrate_upgrade4scCs¸tdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒddlm}m}|jj|ddƒƒ|jjƒdS( Ns&python app_custom_directory.py db initis)python app_custom_directory.py db migrates)python app_custom_directory.py db upgradei(R$R%R&R'(R Rtapp_custom_directoryR$R%R)R*R+(RR,R-R.R$R%((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyttest_custom_directory@scCs·tdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒ|jd|kƒdS(Ns#python app_compare_type1.py db initis&python app_compare_type1.py db migrates&python app_compare_type1.py db upgrades&python app_compare_type2.py db migratesBDetected type change from VARCHAR(length=128) to String(length=10)(R R(RR,R-R.((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyttest_compare_typeLs (t__name__t __module__RRR#R/R1R2(((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyR s     t__main__( RRtunittestRRR tTestCaseR R3tmain(((sD/home/miguel/Documents/dev/flask/flask-migrate/tests/test_migrate.pyts      H Flask-Migrate-1.7.0/tests/test_multidb_migrate.py0000755060175106010010000000530612557213210022302 0ustar miguelNone00000000000000from __future__ import print_function import os import shutil import unittest import subprocess import shlex import sqlite3 def run_cmd(cmd): """Run a command and return a tuple with (stdout, stderr, exit_code)""" process = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = process.communicate() return stdout, stderr, process.wait() class TestMigrate(unittest.TestCase): def setUp(self): os.chdir(os.path.split(os.path.abspath(__file__))[0]) try: os.remove('app1.db') os.remove('app2.db') except OSError: pass try: shutil.rmtree('migrations') except OSError: pass def tearDown(self): try: os.remove('app1.db') os.remove('app2.db') except OSError: pass try: shutil.rmtree('migrations') except OSError: pass def test_multidb_migrate_upgrade(self): (o, e, s) = run_cmd('python app_multidb.py db init --multidb') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_multidb.py db migrate') self.assertTrue(s == 0) (o, e, s) = run_cmd('python app_multidb.py db upgrade') self.assertTrue(s == 0) # ensure the tables are in the correct databases conn1 = sqlite3.connect('app1.db') c = conn1.cursor() c.execute('select name from sqlite_master') tables = c.fetchall() conn1.close() self.assertEqual(tables, [('alembic_version',), ('user',)]) conn2 = sqlite3.connect('app2.db') c = conn2.cursor() c.execute('select name from sqlite_master') tables = c.fetchall() conn2.close() self.assertEqual(tables, [('alembic_version',), ('group',)]) # ensure the databases can be written to from .app_multidb import db, User, Group db.session.add(User(name='test')) db.session.add(Group(name='group')) db.session.commit() # ensure the downgrade works (o, e, s) = run_cmd('python app_multidb.py db downgrade') self.assertTrue(s == 0) conn1 = sqlite3.connect('app1.db') c = conn1.cursor() c.execute('select name from sqlite_master') tables = c.fetchall() conn1.close() self.assertEqual(tables, [('alembic_version',)]) conn2 = sqlite3.connect('app2.db') c = conn2.cursor() c.execute('select name from sqlite_master') tables = c.fetchall() conn2.close() self.assertEqual(tables, [('alembic_version',)]) if __name__ == '__main__': unittest.main() Flask-Migrate-1.7.0/tests/test_multidb_migrate.pyc0000644060175106010010000000655112566373760022466 0ustar miguelNone00000000000000ó ˆ½Uc@s—ddlmZddlZddlZddlZddlZddlZddlZd„Zdej fd„ƒYZ e dkr“ej ƒndS(iÿÿÿÿ(tprint_functionNcCsOtjtj|ƒdtjdtjƒ}|jƒ\}}|||jƒfS(sARun a command and return a tuple with (stdout, stderr, exit_code)tstdouttstderr(t subprocesstPopentshlextsplittPIPEt communicatetwait(tcmdtprocessRR((sL/home/miguel/Documents/dev/flask/flask-migrate/tests/test_multidb_migrate.pytrun_cmd s t TestMigratecBs#eZd„Zd„Zd„ZRS(cCs„tjtjjtjjtƒƒdƒytjdƒtjdƒWntk rZnXytj dƒWntk rnXdS(Nisapp1.dbsapp2.dbt migrations( tostchdirtpathRtabspatht__file__tremovetOSErrortshutiltrmtree(tself((sL/home/miguel/Documents/dev/flask/flask-migrate/tests/test_multidb_migrate.pytsetUps)   cCs[ytjdƒtjdƒWntk r1nXytjdƒWntk rVnXdS(Nsapp1.dbsapp2.dbR(RRRRR(R((sL/home/miguel/Documents/dev/flask/flask-migrate/tests/test_multidb_migrate.pyttearDown s   c CsItdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒtdƒ\}}}|j|dkƒtjdƒ}|jƒ}|jdƒ|jƒ}|jƒ|j|ddgƒtjd ƒ}|jƒ}|jdƒ|jƒ}|jƒ|j|ddgƒd d l m }m } m } |j j| d dƒƒ|j j| d d ƒƒ|j jƒtdƒ\}}}|j|dkƒtjdƒ}|jƒ}|jdƒ|jƒ}|jƒ|j|dgƒtjd ƒ}|jƒ}|jdƒ|jƒ}|jƒ|j|dgƒdS(Ns'python app_multidb.py db init --multidbis python app_multidb.py db migrates python app_multidb.py db upgradesapp1.dbsselect name from sqlite_mastertalembic_versiontusersapp2.dbtgroupi(tdbtUsertGrouptnamettests"python app_multidb.py db downgrade(salembic_version(suser(salembic_version(sgroup(salembic_version(salembic_version(R t assertTruetsqlite3tconnecttcursortexecutetfetchalltcloset assertEqualt app_multidbRRR tsessiontaddtcommit( Rtotetstconn1tcttablestconn2RRR ((sL/home/miguel/Documents/dev/flask/flask-migrate/tests/test_multidb_migrate.pyttest_multidb_migrate_upgrade+sH                 (t__name__t __module__RRR6(((sL/home/miguel/Documents/dev/flask/flask-migrate/tests/test_multidb_migrate.pyR s t__main__( t __future__RRRtunittestRRR$R tTestCaseR R7tmain(((sL/home/miguel/Documents/dev/flask/flask-migrate/tests/test_multidb_migrate.pyts       H Flask-Migrate-1.7.0/tests/__init__.py0000644060175106010010000000000112556326504017624 0ustar miguelNone00000000000000 Flask-Migrate-1.7.0/tests/__init__.pyc0000644060175106010010000000022712557202655020002 0ustar miguelNone00000000000000ó D­¹Uc@sdS(N((((s@/home/miguel/Documents/dev/flask/flask-migrate/tests/__init__.pyts