Here are the examples of the python api sqlalchemy.engine_from_config taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
137 Examples
3
Source : passivessldb.py
with GNU Affero General Public License v3.0
from D4-project
with GNU Affero General Public License v3.0
from D4-project
def connect(self):
""" Connect to the database server """
try:
# connect to the PostgreSQL server
print('Connecting to the PostgreSQL database...')
self.conn = engine_from_config(self.params, prefix='sqlalchemy.')
# self.conn = engine_from_config(self.params, prefix='sqlalchemy.', echo = True)
self.meta = MetaData(self.conn)
self.pkTable = Table('public_key', self.meta, autoload=True)
self.certTable = Table('certificate', self.meta, autoload=True)
self.pkcLink = Table('many_certificate_has_many_public_key', self.meta, autoload=True)
self.sessionTable = Table('sessionRecord', self.meta, autoload=True)
self.srcLink = Table('many_sessionRecord_has_many_certificate', self.meta, autoload=True)
except (Exception) as error:
print(error)
def disconnect(self):
3
Source : conftest.py
with MIT License
from dialoguemd
with MIT License
from dialoguemd
def engine(environ):
from sqlalchemy import engine_from_config
engine = engine_from_config(environ, prefix="sqlalchemy_")
return engine
@fixture(autouse=True)
3
Source : snippet.py
with Apache License 2.0
from dockerizeme
with Apache License 2.0
from dockerizeme
def init_model(settings):
from sqlalchemy import engine_from_config
from sqlalchemy.orm import sessionmaker
from zope.sqlalchemy import ZopeTransactionExtension
engine = engine_from_config(settings, 'sqlalchemy.')
settings['db.engine'] = engine
maker = sessionmaker(bind=engine, extension=ZopeTransactionExtension())
settings['db.maker'] = maker
# tutorial/model/users.py
import logging
3
Source : env.py
with GNU Affero General Public License v3.0
from freedomofpress
with GNU Affero General Public License v3.0
from freedomofpress
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section), prefix="sqlalchemy.", poolclass=pool.NullPool
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
3
Source : test_engine.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_legacy_schema_flag(self):
cfg = {
"sqlalchemy.url": "mssql://foodsn",
"sqlalchemy.legacy_schema_aliasing": "false",
}
e = engine_from_config(
cfg, module=Mock(version="MS SQL Server 11.0.92")
)
eq_(e.dialect.legacy_schema_aliasing, False)
class FastExecutemanyTest(fixtures.TestBase):
3
Source : test_parseconnect.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_engine_from_config(self):
dbapi = mock_dbapi
config = {
"sqlalchemy.url": "postgresql://scott:tiger@somehost/test"
"?fooz=somevalue",
"sqlalchemy.pool_recycle": "50",
"sqlalchemy.echo": "true",
}
e = engine_from_config(config, module=dbapi, _initialize=False)
assert e.pool._recycle == 50
assert e.url == url.make_url(
"postgresql://scott:tiger@somehost/test?foo" "z=somevalue"
)
assert e.echo is True
def test_pool_reset_on_return_from_config(self):
3
Source : test_parseconnect.py
with Apache License 2.0
from gethue
with Apache License 2.0
from gethue
def test_pool_reset_on_return_from_config(self):
dbapi = mock_dbapi
for value, expected in [
("rollback", pool.reset_rollback),
("commit", pool.reset_commit),
("none", pool.reset_none),
]:
config = {
"sqlalchemy.url": "postgresql://scott:tiger@somehost/test",
"sqlalchemy.pool_reset_on_return": value,
}
e = engine_from_config(config, module=dbapi, _initialize=False)
eq_(e.pool._reset_on_return, expected)
def test_engine_from_config_custom(self):
3
Source : install.py
with GNU General Public License v3.0
from martinkirch
with GNU General Public License v3.0
from martinkirch
def create_db_schema(self, path_toml=None):
if not path_toml:
path_toml = self.path_toml
from showergel.db import Base
# indirectly import all Base subclasses:
from showergel import rest
with open(path_toml, 'r') as f:
config = toml.load(f)
engine = engine_from_config(config['db']['sqlalchemy'], prefix='')
Base.metadata.create_all(engine)
def ask_liquid_script(self):
3
Source : manager.py
with BSD 3-Clause "New" or "Revised" License
from mononobi
with BSD 3-Clause "New" or "Revised" License
from mononobi
def _create_engine(self, database_configs, **kwargs):
"""
creates a database engine using specified database configuration and returns it.
each provided key from kwargs will override the corresponding
key in database_configs dict. note that kwargs should not have any prefix.
:param dict database_configs: database configs that should be used.
:returns: database engine
:rtype: Engine
"""
kwargs.update(future=True)
configs_prefix = self.get_configs_prefix()
return engine_from_config(database_configs, prefix=configs_prefix, **kwargs)
def get_configs_prefix(self):
3
Source : env.py
with MIT License
from nsidnev
with MIT License
from nsidnev
def run_migrations_online() -> None:
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
run_migrations_online()
3
Source : db.py
with GNU General Public License v3.0
from PnX-SI
with GNU General Public License v3.0
from PnX-SI
def sqlalchemy_engine_from_config(configfile:str) -> Engine:
'''Returns an sqlalchemy engine'''
with open(configfile, 'r') as cf:
config = ConfigParser()
config.read_file(cf)
return engine_from_config(
dict(config.items('main')),
prefix='sqlalchemy.'
)
def get_site_id(engine: Engine, sitename:str):
3
Source : setup.py
with MIT License
from shazow
with MIT License
from shazow
def _setup_models(settings):
""" Attach connection to model modules. """
if not settings:
return
from sqlalchemy import engine_from_config
from briefmetrics import model
engine = engine_from_config(settings, 'sqlalchemy.')
model.init(engine)
if settings.get('testing'):
# Show unicode warnings as errors in testing.
import warnings
warnings.filterwarnings('error')
warnings.filterwarnings('once', category=DeprecationWarning, module='html5lib')
def _setup_cache_regions(settings):
3
Source : env.py
with MIT License
from skb1129
with MIT License
from skb1129
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.
"""
configuration = config.get_section(config.config_ini_section)
configuration["sqlalchemy.url"] = settings.SQLALCHEMY_DATABASE_URI
connectable = engine_from_config(configuration, prefix="sqlalchemy.", poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata, compare_type=True)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
3
Source : test_deprecations.py
with MIT License
from sqlalchemy
with MIT License
from sqlalchemy
def test_legacy_schema_flag(self, cfg, expected):
with testing.expect_deprecated("The legacy_schema_aliasing parameter"):
e = engine_from_config(
cfg, module=Mock(version="MS SQL Server 11.0.92")
)
is_(e.dialect.legacy_schema_aliasing, expected)
def test_result_map(self):
3
Source : test_parseconnect.py
with MIT License
from sqlalchemy
with MIT License
from sqlalchemy
def test_engine_from_config(self):
dbapi = mock_dbapi
config = {
"sqlalchemy.url": "postgresql+psycopg2://scott:tiger@somehost/test"
"?fooz=somevalue",
"sqlalchemy.pool_recycle": "50",
"sqlalchemy.echo": "true",
}
e = engine_from_config(config, module=dbapi, _initialize=False)
assert e.pool._recycle == 50
assert e.url == url.make_url(
"postgresql+psycopg2://scott:tiger@somehost/test?foo" "z=somevalue"
)
assert e.echo is True
def test_engine_from_config_future_parameter_ignored(self):
3
Source : test_parseconnect.py
with MIT License
from sqlalchemy
with MIT License
from sqlalchemy
def test_engine_from_config_future_parameter_ignored(self):
dbapi = mock_dbapi
config = {
"sqlalchemy.url": "postgresql+psycopg2://scott:tiger@somehost/test"
"?fooz=somevalue",
"sqlalchemy.future": "true",
}
engine_from_config(config, module=dbapi, _initialize=False)
def test_engine_from_config_future_false_raises(self):
3
Source : test_parseconnect.py
with MIT License
from sqlalchemy
with MIT License
from sqlalchemy
def test_engine_from_config_future_false_raises(self):
dbapi = mock_dbapi
config = {
"sqlalchemy.url": "postgresql+psycopg2://scott:tiger@somehost/test"
"?fooz=somevalue",
"sqlalchemy.future": "false",
}
with expect_raises_message(
exc.ArgumentError,
r"The 'future' parameter passed to create_engine\(\) "
r"may only be set to True.",
):
engine_from_config(config, module=dbapi, _initialize=False)
def test_pool_reset_on_return_from_config(self):
3
Source : test_parseconnect.py
with MIT License
from sqlalchemy
with MIT License
from sqlalchemy
def test_pool_reset_on_return_from_config(self):
dbapi = mock_dbapi
for value, expected in [
("rollback", pool.reset_rollback),
("commit", pool.reset_commit),
("none", pool.reset_none),
]:
config = {
"sqlalchemy.url": "postgresql+psycopg2://scott:tiger@somehost/test", # noqa
"sqlalchemy.pool_reset_on_return": value,
}
e = engine_from_config(config, module=dbapi, _initialize=False)
eq_(e.pool._reset_on_return, expected)
def test_engine_from_config_custom(self):
3
Source : alembic_helpers.py
with MIT License
from talkpython
with MIT License
from talkpython
def table_has_column(table, column):
config = op.get_context().config
engine = engine_from_config(
config.get_section(config.config_ini_section), prefix='sqlalchemy.')
insp = reflection.Inspector.from_engine(engine)
has_column = False
for col in insp.get_columns(table):
if column not in col['name']:
continue
has_column = True
return has_column
3
Source : env.py
with MIT License
from xolox
with MIT License
from xolox
def run_migrations_online(**options):
"""Run migrations in 'online' mode."""
connectable = engine_from_config(
context.config.get_section(context.config.config_ini_section), prefix="sqlalchemy.", poolclass=pool.NullPool
)
with connectable.connect() as connection:
context.configure(
# Enable 'online' mode.
connection=connection,
# Pass on the common options.
**options
)
with context.begin_transaction():
context.run_migrations()
# Execute any pending migrations when this script is run.
run_migrations()
0
Source : env.py
with MIT License
from 3lpsy
with MIT License
from 3lpsy
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.zzzcomputing.com/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.")
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
process_revision_directives=process_revision_directives,
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from 4Catalyzer
with MIT License
from 4Catalyzer
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with GNU General Public License v3.0
from aertslab
with GNU General Public License v3.0
from aertslab
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from AIforGoodSimulator
with MIT License
from AIforGoodSimulator
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.zzzcomputing.com/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.')
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
process_revision_directives=process_revision_directives,
**current_app.extensions['migrate'].configure_args
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from aio-libs
with MIT License
from aio-libs
def run_migrations_online() -> None:
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from airq-dev
with MIT License
from airq-dev
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.zzzcomputing.com/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.")
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
process_revision_directives=process_revision_directives,
**current_app.extensions["migrate"].configure_args
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with Apache License 2.0
from airshipit
with Apache License 2.0
from airshipit
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with Apache License 2.0
from airshipit
with Apache License 2.0
from airshipit
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.
"""
db_url = os.environ['DRYDOCK_DB_URL']
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool,
url=db_url)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from aliev
with MIT License
from aliev
async 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.
"""
connectable = AsyncEngine(
engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
future=True,
)
)
async with connectable.connect() as connection:
await connection.run_sync(do_run_migrations)
if context.is_offline_mode():
0
Source : env.py
with MIT License
from alisezer
with MIT License
from alisezer
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.zzzcomputing.com/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():
0
Source : env.py
with MIT License
from ameserole
with MIT License
from ameserole
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():
0
Source : env.py
with MIT License
from apoclyps
with MIT License
from apoclyps
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.zzzcomputing.com/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():
0
Source : dbconnector.py
with GNU General Public License v3.0
from Artikash
with GNU General Public License v3.0
from Artikash
def __init__(self, configuration):
"""
Constructs the DatabaseConnector object and connects to the database
specified by the options given in databaseSettings.
To connect to a database give
``{'sqlalchemy.url': 'driver://user:pass@host/database'``} as
configuration. Further databases can be attached by passing a list
of URLs or names for keyword ``'attach'``.
.. seealso::
documentation of sqlalchemy.create_engine()
:type configuration: dict
:param configuration: database connection options for SQLAlchemy
"""
if not configuration:
configuration = {}
elif isinstance(configuration, basestring):
# backwards compatibility to option databaseUrl
configuration = {'sqlalchemy.url': configuration}
else:
configuration = configuration.copy()
# allow 'url' as parameter, but move to 'sqlalchemy.url'
if 'url' in configuration:
if ('sqlalchemy.url' in configuration
and configuration['sqlalchemy.url'] != configuration['url']):
raise ValueError("Two different URLs specified"
" for 'url' and 'sqlalchemy.url'."
"Check your configuration.")
else:
configuration['sqlalchemy.url'] = configuration.pop('url')
self.databaseUrl = configuration['sqlalchemy.url']
"""Database url"""
registerUnicode = configuration.pop('registerUnicode', False)
if isinstance(registerUnicode, basestring):
registerUnicode = (registerUnicode.lower()
in ['1', 'yes', 'true', 'on'])
self.registerUnicode = registerUnicode
self.engine = engine_from_config(configuration, prefix='sqlalchemy.')
"""SQLAlchemy engine object"""
self.connection = self.engine.connect()
"""SQLAlchemy database connection object"""
self.metadata = MetaData(bind=self.connection)
"""SQLAlchemy metadata object"""
# multi-database table access
self.tables = LazyDict(self._tableGetter())
"""Dictionary of SQLAlchemy table objects"""
if self.engine.name == 'sqlite':
# Main database can be prefixed with 'main.'
self._mainSchema = 'main'
else:
# MySQL uses database name for prefix
self._mainSchema = self.engine.url.database
# attach other databases
self.attached = OrderedDict()
"""Mapping of attached database URLs to internal schema names"""
attach = configuration.pop('attach', [])
searchPaths = self.engine.name == 'sqlite'
for url in self._findAttachableDatabases(attach, searchPaths):
self.attachDatabase(url)
# register unicode functions
self.compatibilityUnicodeSupport = False
if self.registerUnicode:
self._registerUnicode()
def _findAttachableDatabases(self, attachList, searchPaths=False):
0
Source : env.py
with Apache License 2.0
from asharov
with Apache License 2.0
from asharov
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.
"""
configuration = config.get_section(config.config_ini_section)
configuration['sqlalchemy.url'] = os.environ['HAMMER_DATABASE_URL']
connectable = engine_from_config(
configuration,
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from Aurora-Admin-Panel
with MIT License
from Aurora-Admin-Panel
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.
"""
configuration = config.get_section(config.config_ini_section)
configuration["sqlalchemy.url"] = get_url()
connectable = engine_from_config(
configuration,
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection,
render_as_batch=True,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with Apache License 2.0
from bcgov
with Apache License 2.0
from bcgov
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.zzzcomputing.com/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.')
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
process_revision_directives=process_revision_directives,
compare_type=True,
include_object=include_object,
**current_app.extensions['migrate'].configure_args
)
with context.begin_transaction():
context.run_migrations()
def include_object(object, name, type_, reflected, compare_to):
0
Source : env.py
with Apache License 2.0
from bcgov
with Apache License 2.0
from bcgov
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.
"""
alembic_config = config.get_section(config.config_ini_section)
alembic_config['sqlalchemy.url'] = config.get_main_option("sqlalchemy.url")
connectable = engine_from_config(
alembic_config,
prefix='sqlalchemy.',
poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with GNU General Public License v3.0
from bitcartcc
with GNU General Public License v3.0
from bitcartcc
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.
"""
alembic_config = config.get_section(config.config_ini_section)
alembic_config["sqlalchemy.url"] = CONNECTION_STR
connectable = engine_from_config(alembic_config, prefix="sqlalchemy.", poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(compare_type=True, connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from bkerler
with MIT License
from bkerler
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from bkerler
with MIT License
from bkerler
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.
"""
# for the direct-to-DB use case, start a transaction on all
# engines, then run all migrations, then commit all transactions.
engines = {}
for name in re.split(r',\s*', db_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)
context.configure(
connection=rec['connection'],
upgrade_token="%s_upgrades" % name,
downgrade_token="%s_downgrades" % name,
target_metadata=target_metadata.get(name)
)
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():
0
Source : env.py
with MIT License
from Blockstream
with MIT License
from Blockstream
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection,
target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from briancappello
with MIT License
from briancappello
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.
"""
# do not auto-generate an empty migration when there's nothing to do
def process_revision_directives(context, revision, directives):
if config.cmd_opts.autogenerate:
script = directives[0]
if script.upgrade_ops.is_empty():
directives[:] = []
connectable = engine_from_config(
config.get_section(config.config_ini_section),
url=Config.DATABASE_URI,
prefix='sqlalchemy.',
poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
process_revision_directives=process_revision_directives,
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from cc-archive
with MIT License
from cc-archive
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata,
include_object=include_object
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from cds-snc
with MIT License
from cds-snc
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.
"""
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, compare_type=True)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
if context.is_offline_mode():
0
Source : env.py
with Apache License 2.0
from CloudmindsRobot
with Apache License 2.0
from CloudmindsRobot
def run_migrations_online() -> None:
"""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: https://alembic.sqlalchemy.org/en/latest/cookbook.html
def process_revision_directives( # pylint: disable=redefined-outer-name, unused-argument
context: MigrationContext, revision: str, directives: List[MigrationScript]
) -> None:
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()
kwargs = {}
if engine.name in ("sqlite", "mysql"):
kwargs = {"transaction_per_migration": True, "transactional_ddl": True}
configure_args = current_app.extensions["migrate"].configure_args
if configure_args:
kwargs.update(configure_args)
context.configure(
connection=connection,
target_metadata=target_metadata,
# compare_type=True,
process_revision_directives=process_revision_directives,
**kwargs
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
if context.is_offline_mode():
0
Source : env.py
with GNU General Public License v3.0
from containerbuildsystem
with GNU General Public License v3.0
from containerbuildsystem
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.zzzcomputing.com/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.")
connectable = engine_from_config(
config.get_section(config.config_ini_section), prefix="sqlalchemy.", poolclass=pool.NullPool
)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
process_revision_directives=process_revision_directives,
render_as_batch=True,
**current_app.extensions["migrate"].configure_args,
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
0
Source : env.py
with MIT License
from crazymidnight
with MIT License
from crazymidnight
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.zzzcomputing.com/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()
except Exception as exception:
logger.error(exception)
raise exception
finally:
connection.close()
if context.is_offline_mode():
0
Source : env.py
with Apache License 2.0
from deep-learning-indaba
with Apache License 2.0
from deep-learning-indaba
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.
"""
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
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
if context.is_offline_mode():
0
Source : __init__.py
with MIT License
from dialoguemd
with MIT License
from dialoguemd
def startup():
lowercase_environ = {
k.lower(): v for k, v in os.environ.items() if k.lower() != "sqlalchemy_warn_20"
}
engine = engine_from_config(lowercase_environ, prefix="sqlalchemy_")
aws_rds_iam_support.setup(engine.engine)
Base.metadata.bind = engine
Base.prepare(engine)
_Session.configure(bind=engine)
# Fail early:
try:
with open_session() as session:
session.execute(text("select 'OK'"))
except Exception:
logger.critical(
"Fail querying db: is sqlalchemy_url envvar correctly configured?"
)
raise
logger.info("startup", engine=engine)
class Base(declarative_base(cls=DeferredReflection)): # type: ignore
0
Source : env.py
with GNU General Public License v3.0
from DIGITALCRIMINAL
with GNU General Public License v3.0
from DIGITALCRIMINAL
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.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata,
render_as_batch=True,
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
See More Examples