def load_environment(global_conf, app_conf):
"""\
Configure the Pylons environment via the ``pylons.config`` object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(global_conf,
app_conf,
package='openspending.ui',
paths=paths)
config['routes.map'] = routing.make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = helpers
# set log level in markdown
markdown.logger.setLevel(logging.WARN)
# SQLAlchemy
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
# Configure Solr
import openspending.lib.solr_util as solr
solr.configure(config)
def load_environment(global_conf, app_conf):
"""\
Configure the Pylons environment via the ``pylons.config`` object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(
global_conf,
app_conf,
package='openspending.ui',
paths=paths)
config['routes.map'] = routing.make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = helpers
# set log level in markdown
markdown.logger.setLevel(logging.WARN)
# SQLAlchemy
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
# Configure Solr
import openspending.lib.solr_util as solr
solr.configure(config)
def load_environment(global_conf, app_conf):
"""\
Configure the Pylons environment via the ``pylons.config`` object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(global_conf, app_conf, package='openspending.ui', paths=paths)
config['routes.map'] = routing.make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = helpers
# set log level in markdown
markdown.logger.setLevel(logging.WARN)
# Establish celery loader:
from openspending.command import celery
# Translator (i18n)
config['openspending.ui.translations'] = MultiDomainTranslator([config.get('lang', 'en')])
translator = Translator(config['openspending.ui.translations'])
def template_loaded(template):
translator.setup(template)
template_paths = [paths['templates'][0]]
extra_template_paths = config.get('extra_template_paths', '')
if extra_template_paths:
# must be first for them to override defaults
template_paths = extra_template_paths.split(',') + template_paths
# Create the Genshi TemplateLoader
config['pylons.app_globals'].genshi_loader = TemplateLoader(
search_path=template_paths,
auto_reload=True,
callback=template_loaded
)
# SQLAlchemy
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
# Configure Solr
import openspending.lib.solr_util as solr
solr.configure(config)
def setup_database(self):
"""
Configure the database based on the provided configuration
file, but be sure to overwrite the url so that it will use
sqlite in memory, irrespective of what the user has set in
test.ini. Construct the sqlalchemy engine with versioning
and initialise everything.
"""
config['openspending.db.url'] = 'sqlite:///:memory:'
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
def setup_package():
'''
Create a new, not scoped global sqlalchemy session
and rebind it to a new root transaction to which we can roll
back. Otherwise :func:`adhocracy.model.init_model`
will create as scoped session and invalidates
the connection we need to begin a new root transaction.
Return: The new root `connection`
'''
from sqlalchemy import engine_from_config
from migrate.versioning.util import construct_engine
config['openspending.db.url'] = 'sqlite:///:memory:'
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
def setup_package():
'''
Create a new, not scoped global sqlalchemy session
and rebind it to a new root transaction to which we can roll
back. Otherwise :func:`adhocracy.model.init_model`
will create as scoped session and invalidates
the connection we need to begin a new root transaction.
Return: The new root `connection`
'''
from sqlalchemy import engine_from_config
from migrate.versioning.util import construct_engine
config['openspending.db.url'] = 'sqlite:///:memory:'
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
def load_environment(global_conf, app_conf):
"""Configure the Pylons environment via the ``pylons.config``
object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(global_conf, app_conf, package='openspending.etl.ui', paths=paths)
config['routes.map'] = make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = helpers
# set log level in markdown
markdown.logger.setLevel(logging.WARN)
## redo template setup to use genshi.search_path (so remove std template setup)
template_paths = [paths['templates'][0]]
# Translator (i18n)
config['openspending.etl.ui.translations'] = MultiDomainTranslator([config.get('lang', 'en')])
translator = Translator(config['openspending.etl.ui.translations'])
def template_loaded(template):
translator.setup(template)
config['pylons.app_globals'].genshi_loader = TemplateLoader(
template_paths, auto_reload=True, callback=template_loaded)
# SQLAlchemy
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
# Configure ckan
import openspending.etl.importer.ckan as ckan
ckan.configure(config)
# Configure Solr
import openspending.lib.solr_util as solr
solr.configure(config)
def load_environment(global_conf, app_conf):
"""\
Configure the Pylons environment via the ``pylons.config`` object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(
global_conf,
app_conf,
package='openspending.ui',
paths=paths)
config['routes.map'] = routing.make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = helpers
# set log level in markdown
markdown.logger.setLevel(logging.WARN)
# Establish celery loader
# This must be done (even if it results in a pyflakes error) because
# celery loading is done from openspending.command.celery.__init__.py
# Fixing that loading is how you would fix the flakes error
from openspending.command import celery
# SQLAlchemy
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
# Configure Solr
import openspending.lib.solr_util as solr
solr.configure(config)
def load_environment(global_conf, app_conf):
"""\
Configure the Pylons environment via the ``pylons.config`` object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(global_conf,
app_conf,
package='openspending.ui',
paths=paths)
config['routes.map'] = routing.make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = helpers
# set log level in markdown
markdown.logger.setLevel(logging.WARN)
# Establish celery loader
# This must be done (even if it results in a pyflakes error) because
# celery loading is done from openspending.command.celery.__init__.py
# Fixing that loading is how you would fix the flakes error
from openspending.command import celery
# SQLAlchemy
engine = engine_from_config(config, 'openspending.db.')
engine = construct_engine(engine)
init_model(engine)
# Configure Solr
import openspending.lib.solr_util as solr
solr.configure(config)