def main(*args, **settings):
from pyramid.config import Configurator
from pyramid.events import NewRequest, ContextFound
from pyramid.authentication import BasicAuthAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.renderers import JSON, JSONP
logger.info('Start registry api...')
read_users(settings['auth.file'])
config = Configurator(autocommit=True,
settings=settings,
authentication_policy=BasicAuthAuthenticationPolicy(
auth_check, __name__),
authorization_policy=ACLAuthorizationPolicy(),
root_factory=Root,
route_prefix=ROUTE_PREFIX)
config.include('pyramid_exclog')
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_subscriber(add_logging_context, NewRequest)
config.add_subscriber(set_logging_context, ContextFound)
config.add_subscriber(set_renderer, NewRequest)
config.add_route('health', '/health')
config.add_route('registry', '/registry/{param}.json')
config.scan('openprocurement.medicines.registry.api.views')
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(settings=settings)
config.set_authentication_policy(AuthenticationPolicy(None))
config.set_authorization_policy(AuthorizationPolicy())
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_subscriber(set_renderer, NewRequest)
config.include("cornice")
config.route_prefix = '/api/{}'.format(VERSION)
config.scan("openprocurement.api.views")
# CouchDB connection
server = Server(settings.get('couchdb.url'))
config.registry.couchdb_server = server
db_name = os.environ.get('DB_NAME', settings['couchdb.db_name'])
if db_name not in server:
server.create(db_name)
config.registry.db = server[db_name]
# sync couchdb views
sync_design(config.registry.db)
# migrate data
migrate_data(config.registry.db)
# S3 connection
if 'aws.access_key' in settings and 'aws.secret_key' in settings and 'aws.bucket' in settings:
connection = S3Connection(settings['aws.access_key'], settings['aws.secret_key'])
config.registry.s3_connection = connection
bucket_name = settings['aws.bucket']
if bucket_name not in [b.name for b in connection.get_all_buckets()]:
connection.create_bucket(bucket_name, location=Location.EU)
config.registry.bucket_name = bucket_name
return config.make_wsgi_app()
def main(global_config, **settings):
from openprocurement.integrations.edr.auth import (authenticated_role)
from openprocurement.integrations.edr.utils import (
forbidden, add_logging_context, set_logging_context, request_params,
set_renderer, Root, read_users)
from openprocurement.integrations.edr.utils import auth_check
from pyramid.authentication import BasicAuthAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.config import Configurator
from pyramid.events import NewRequest, ContextFound
from pyramid.renderers import JSON, JSONP
LOGGER.info('Start edr api')
read_users(settings['auth.file'])
config = Configurator(
autocommit=True,
settings=settings,
authentication_policy=BasicAuthAuthenticationPolicy(
auth_check, __name__),
authorization_policy=ACLAuthorizationPolicy(),
root_factory=Root,
route_prefix=ROUTE_PREFIX,
)
config.include('pyramid_exclog')
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_renderer(
'yaml', 'openprocurement.integrations.edr.renderers.YAMLRenderer')
config.add_subscriber(add_logging_context, NewRequest)
config.add_subscriber(set_logging_context, ContextFound)
config.add_subscriber(set_renderer, NewRequest)
# Init edr connection
config.registry.edr_client = EdrClient(
settings.get('edr_api_server'), settings.get('edr_api_token'),
int(settings.get('edr_api_port')),
float(settings.get('edr_timeout_min', 1)),
float(settings.get('edr_timeout_max', 60)),
float(settings.get('edr_timeout_step', 2)),
settings.get('edr_timeout_mode', 'mult'))
config.registry.cache_db = Db(settings)
config.registry.time_to_live = settings.get("time_to_live", 300)
config.registry.time_to_live_negative = settings.get(
"time_to_live_negative", 30)
LOGGER.info("SANDBOX_MODE = {}".format(SANDBOX_MODE))
# Include views
config.add_route('verify', '/verify')
config.add_route('details', '/details/{id}')
config.add_route('health', '/health')
config.scan("openprocurement.integrations.edr.views")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# Engine configuration #
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
my_session_factory = SignedCookieSessionFactory('spencersgeruchallenge')
config = Configurator(settings=settings,
session_factory=my_session_factory,
root_factory='.models.Root')
config.include('pyramid_jinja2')
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name='callback'))
# Endpoint routes
config.add_route('home', '/')
config.add_route('quotes', '/quotes')
config.add_route('random', '/quotes/random')
config.add_route('test_db', '/test_db')
config.add_route('quote_by_num', '/quotes/{quoteNum}')
config.add_route('query', '/api_query')
config.scan()
return config.make_wsgi_app()
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp()
self.config.add_renderer("jsonp", JSONP(param_name="callback"))
self.config.include("cornice")
self.config.registry.server_id = uuid4().hex
self.config.add_request_method(check_accreditations)
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.config.add_subscriber(add_logging_context, NewRequest)
self.config.add_subscriber(set_logging_context, ContextFound)
self.config.add_request_method(authenticated_role, reify=True)
self.config.include(
"openprocurement.historical.core.includeme.includeme")
self.config.registry.db = db
self.authn_policy = AuthenticationPolicy(
"{}/auth.ini".format(os.path.dirname(os.path.abspath(__file__))),
__name__)
self.config.set_authentication_policy(self.authn_policy)
self.config.scan("openprocurement.historical.core.tests.utils")
self.app = TestApp(self.config.make_wsgi_app())
self.app.authorization = ("Basic", ("broker", ""))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
authentication_policy = AuthenticationPolicy(settings['auth.secret'],
cookie_name='frostcms',
callback=groupfinder)
authorization_policy = ACLAuthorizationPolicy()
my_session_factory = UnencryptedCookieSessionFactoryConfig('1@3$msT')
config = Configurator(settings=settings,
root_factory='frostcms.security.RootFactory',
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
session_factory=my_session_factory,
request_factory=MainRequest)
jsonp_renderer = JSONP(param_name='callback')
config.add_renderer('jsonp', jsonp_renderer)
config.add_static_view('static', 'frostcms:static', cache_max_age=3600)
config.add_static_view('upload', 'frostcms:upload')
config.include("frostcms.views")
config.include("frostcms.assignment")
config.include("frostcms.user")
config.include("frostcms.mentor")
config.include("frostcms.student")
config.include("frostcms.faculty")
config.include("frostcms.location")
config.include("frostcms.college")
config.include("frostcms.semester")
config.include("frostcms.clazz")
config.include("frostcms.public")
config.include("frostcms.lesson")
config.include("frostcms.course")
config.include("frostcms.courseware")
return config.make_wsgi_app()
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp()
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.authn_policy = AuthTktAuthenticationPolicy('$3kr1t')
self.config.set_authentication_policy(self.authn_policy)
add_view(ThingImp.collection_get, permission='read')
thing_resource = add_resource(ThingImp,
collection_path='/thing',
path='/thing/{id}',
name='thing_service',
collection_acl=my_collection_acl)
add_view(UserImp.get, renderer='json')
add_view(UserImp.get, renderer='jsonp')
add_view(UserImp.collection_post, renderer='json', accept='text/json')
user_resource = add_resource(UserImp,
collection_path='/users',
path='/users/{id}',
name='user_service',
factory=dummy_factory)
self.config.add_cornice_resource(thing_resource)
self.config.add_cornice_resource(user_resource)
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp(autocommit=False)
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
self.config.scan("cornice.tests.test_resource")
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
setup_logging(global_config['__file__'])
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_renderer('ujson', factory='app.renderers.UjsonRenderer')
config.add_static_view('static', 'static', cache_max_age=3600)
# initialise a connection to mongo on startup and store the client
# in the registry which will be injected into each request
conf = appConfig(config.registry.settings.get('app.config'))
config.registry.app_config = conf.app_config
config.registry.app_config['mongodb']['client'] = init_mongodb_connection(config.registry.app_config['mongodb'])
config.add_route('home', '/')
config.add_route('health-check', '/health-check')
config.add_route('network-stats', '/stats/{code}/{explore}')
config.add_route('network-build', '/network/{code}/{explore}')
config.add_route('network-build-status', '/network/{code}/{explore}/status')
config.add_route('entity-data', '/entity/{code}/data')
config.add_route('entity-build', '/entity/{code}/{id}')
config.add_route('entity-build-status', '/entity/{code}/{id}/status')
config.add_route('convert-graph', '/convert/{code}')
config.scan()
return config.make_wsgi_app()
def yeastgenome_frontend(backend_url, heritage_url, log_directory, **configs):
chosen_frontend = YeastgenomeFrontend(backend_url, heritage_url, log_directory)
settings = dict(configs)
settings.setdefault('jinja2.i18n.domain', 'myproject')
configurator = Configurator(settings=settings)
configurator.add_translation_dirs('locale/')
configurator.include('pyramid_jinja2')
# set global template var asset_root to read from cloudfront or local, depending on .ini value, default to False
production_assets = configs.get('production_assets', False)
if production_assets == 'True':
file_path = os.path.dirname(os.path.realpath(__file__)) + '/../../../../production_asset_url.json'
asset_root = json.load(open(file_path, 'r'))['url']
else:
asset_root = '/static'
# put query string in global template variable
def add_template_global(event):
event['asset_root'] = asset_root
configurator.add_subscriber(add_template_global, 'pyramid.events.BeforeRender')
# cache everything for 1 month on browser
configurator.add_static_view('static', 'src:sgd/frontend/yeastgenome/static', cache_max_age=2629740)
configurator.add_static_view('img-domain', 'src:sgd/frontend/yeastgenome/img-domain', cache_max_age=2629740)
configurator.add_renderer('jsonp', JSONP(param_name='callback'))
return chosen_frontend, configurator
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
db = models.DBConnect(**settings)
db.connect()
# A very simple default Authentication Policy
authn_policy = AuthTktAuthenticationPolicy('somesecret',
callback=security.groupfinder)
# A very simple default ACL Authorization Policy
authz_policy = ACLAuthorizationPolicy()
# Setting up the config settings to the application config
config = Configurator(settings=settings,
root_factory='qrevent.security.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.add_renderer('jsonp', JSONP(param_name='callback'))
# Setup pyramid_beaker as session factory
session_factory = session_factory_from_settings(settings)
# Set session factory to the pyramid_beaker session factory
config.set_session_factory(session_factory)
config.add_static_view('static', 'qrevent:static')
config.include('qrevent.api.api_include')
config.include('qrevent.web.web_include')
return config.make_wsgi_app()
def setUpClass(cls):
cls.config = testing.setUp()
cls.config.add_renderer('jsonp', JSONP(param_name='callback'))
cls.config.include("cornice")
cls.authz_policy = ACLAuthorizationPolicy()
cls.authn_policy = AuthenticationPolicy(
"{}/auth.ini".format(os.path.dirname(os.path.abspath(__file__))),
__name__)
cls.config.set_authorization_policy(cls.authz_policy)
cls.config.set_authentication_policy(cls.authn_policy)
cls.config.registry.db = MagicMock()
cls.config.registry.db.save.return_value = [
'', '1-{}'.format(uuid.uuid4().hex)
]
cls.config.registry.server_id = uuid.uuid4().hex
cls.config.registry.docservice_key = MagicMock()
cls.config.context = munchify(tender.serialize.return_value)
cls.config.registry.decr_box = Box("b" * 32, "c" * 32)
cls.config.add_subscriber(add_logging_context, NewRequest)
cls.config.add_subscriber(MagicMock(), ContextFound)
cls.config.add_subscriber(MagicMock(), NewRequest)
cls.config.add_subscriber(MagicMock(), BeforeRender)
cls.config.scan("openprocurement.archivarius.core.tests.utils")
cls.app = TestApp(CatchErrors(cls.config.make_wsgi_app()))
def main(global_config, **settings):
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_route('crow_provider', '/provider')
config.add_route('crow_layers', '/layers')
config.add_route('crow_environment_json', '/datasets')
config.add_route('layer_kml', '/kml')
db_url = urlparse(settings['mongo_uri'])
config.registry.db = pymongo.Connection(host=db_url.hostname,
port=db_url.port)
def add_db(request):
db = config.registry.db[db_url.path[1:]]
if db_url.username and db_url.password:
db.authenticate(db_url.username, db_url.password)
return db
config.add_request_method(add_db, 'db', reify=True)
config.scan("compsrest.views")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.include('nurl.pyramid_nurl')
# renderers
config.add_renderer('jsonp', JSONP(param_name='callback'))
# URL patterns
config.add_static_view(path='nurl.webapp:static',
name='static',
cache_max_age=3600)
config.add_route('home', '/')
config.add_route('shortened', '/{short_ref}')
# restful endpoints
config.add_route('shortener_v1', '/api/v1/shorten')
css = webassets.Bundle('bootstrap.min.css',
webassets.Bundle('styles.css', filters='yui_css'),
output='bundle.min.css')
config.add_webasset('css', css)
config.registry.settings['webassets_env'] = config.get_webassets_env()
config.add_subscriber(add_webassets_env, NewRequest)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# Update the settings with the current app root path
settings['app_root'] = abspath(dirname(dirname(__file__)))
initialize_sql(settings)
authn_policy = AuthTktAuthenticationPolicy(
settings.get('auth.secret'), callback=UserMgr.auth_groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory='bookie.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.set_request_factory(RequestWithUserAttribute)
config = build_routes(config)
config.add_static_view('static', 'bookie:static')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.scan('bookie.views')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
app_version = settings.get('app_version')
settings['app_version'] = app_version
config = Configurator(settings=settings)
# init raster files for height/profile and preload COMB file
init_rasterfiles(settings.get('dtm_base_path'), ['COMB'])
# renderers
config.add_renderer(
'jsonp',
JSONP(param_name='callback', indent=None, separators=(',', ':')))
config.add_renderer('csv', CSVRenderer)
# route definitions
config.add_route('profile_json', '/rest/services/profile.json')
config.add_route('profile_csv', '/rest/services/profile.csv')
config.add_route('height', '/rest/services/height')
config.add_route('checker', '/checker')
config.add_route('checker_dev', '/checker_dev')
config.add_static_view('static', 'alti:static')
config.add_static_view('/', 'alti:static/')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authentication_policy = AuthenticationPolicy(
settings['auth.secret'], cookie_name='shike.im')
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings)
config.set_root_factory('hzsxactivitymanagesite.resources.RootFactory')
config.set_authentication_policy(authentication_policy)
config.set_authorization_policy(authorization_policy)
jsonp = JSONP(param_name='callback')
jsonp.add_adapter(ObjectId, objectid_adapter)
jsonp.add_adapter(DBRef, dbref_adapter)
jsonp.add_adapter(datetime.datetime, datetime_adapter)
config.add_renderer('jsonp', jsonp)
config.add_subscriber(real_ip_hook, NewRequest)
config.set_request_property(get_db, "db", reify=True)
config.set_request_property(get_fs, "fs", reify=True)
config.set_request_property(get_user, "user", reify=True)
config.add_static_view('static', 'static', cache_max_age=3600)
config.include("hzsxactivitymanagesite.views.home")
config.add_forbidden_view("hzsxactivitymanagesite.views.forbidden_view", renderer="json")
config.add_notfound_view("hzsxactivitymanagesite.views.notfound_view", renderer="json")
config.add_view("hzsxactivitymanagesite.views.apierror_view", context='hzsxactivitymanagesite.exceptions.APIError', renderer='json')
config.add_view("hzsxactivitymanagesite.views.pageerror_view", context='hzsxactivitymanagesite.exceptions.PageError', renderer='error.mako')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = AuthTktAuthenticationPolicy(
settings['auth.secret'],
secure=True,
http_only=True,
timeout=int(settings['auth.timeout']),
max_age=int(settings['auth.timeout']),
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
root_factory=Root)
if config.get_settings().get('cors.preflight', None) == 'true':
config.include('.cors')
config.add_cors_preflight_handler()
config.include("cornice")
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
upload_dir = os.path.abspath(settings['upload_dir'])
config.add_static_view('upload', upload_dir, cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.scan(ignore=['modmod.scripts', 'modmod.tests'])
config.include('.config')
config.include('modmod.views')
config.include('modmod.views.util')
safile_settings = {
'file.storages': ['fs:' + settings['upload_dir']],
'fs.' + settings['upload_dir'] + '.asset_path': '/upload/',
}
pyramid_safile.init_factory(safile_settings)
init_worker(settings, safile_settings)
stripe.api_key = settings['stripe.api_key']
if not "CI" in os.environ and os.path.isfile(
'secret/fbServiceAccountKey.json'):
cred = credentials.Certificate('secret/fbServiceAccountKey.json')
default_firebase_app = firebase_admin.initialize_app(cred)
signal.signal(signal.SIGINT, sigint_handler)
signal.signal(signal.SIGTERM, sigint_handler)
signal.signal(signal.SIGHUP, sigint_handler)
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
version = settings.get('api_version')
route_prefix = '/api/{}'.format(version)
config = Configurator(
autocommit=True,
settings=settings,
route_prefix=route_prefix,
)
config.include('pyramid_exclog')
config.include("cornice")
config.add_request_method(request_params, 'params', reify=True)
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_subscriber(add_logging_context, NewRequest)
config.add_subscriber(set_logging_context, ContextFound)
config.add_subscriber(set_renderer, NewRequest)
config.add_subscriber(beforerender, BeforeRender)
config.scan("openprocurement.edge.views.spore")
config.scan("openprocurement.edge.views.health")
resources = settings.get('resources') and settings['resources'].split(',')
couch_url = settings.get('couchdb.url') + settings.get('couchdb.db_name')
for resource in resources:
config.scan("openprocurement.edge.views." + resource)
prepare_couchdb_views(couch_url, resource, LOGGER)
LOGGER.info('Push couch {} views successful.'.format(resource))
LOGGER.info('{} resource initialized successful.'.format(
resource.title()))
# CouchDB connection
server = Server(settings.get('couchdb.url'),
session=Session(retry_delays=range(10)))
config.registry.couchdb_server = server
config.registry.db = prepare_couchdb(settings.get('couchdb.url'),
settings.get('couchdb.db_name'),
LOGGER)
config.registry.server_id = settings.get('id', '')
config.registry.health_threshold = float(
settings.get('health_threshold', 99))
config.registry.api_version = version
config.registry.update_after = asbool(settings.get('update_after', True))
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a WSGI application. """
my_session_factory = UnencryptedCookieSessionFactoryConfig("itsaseekreet")
config = Configurator(settings=settings, root_factory=Root,
session_factory=my_session_factory)
config.include("cornice")
config.scan("lembrar.service")
config.add_renderer('jsonp', JSONP(param_name='callback'))
# config.add_view("lembrar.views.list.list_view",
# context="lembrar:resources.Root",
# renderer="lembrar:templates/list.pt")
# config.add_route("thumb", pattern="{id}/thumb")
# config.add_view("lembrar.views.list.thumb", route_name="thumb")
# config.add_route("image", pattern="{id}/image")
# config.add_view("lembrar.views.list.image", route_name="image")
# config.add_route("del", pattern="{id}/delete")
# config.add_view("lembrar.views.list.delete", route_name="del",
# renderer="json")
# config.add_view("lembrar.views.add.add", name="add",
# context="lembrar:resources.Root", renderer="json")
# config.add_view("lembrar.views.add.human_add", name="human_add",
# context="lembrar:resources.Root",
# renderer="lembrar:templates/add.pt")
# config.add_view("lembrar.views.maintenance.upgrade", name="upgrade",
# renderer="json")
# config.add_route("edit", pattern="{id}/edit")
# config.add_view("lembrar.views.edit.edit", route_name="edit",
# renderer="lembrar:templates/edit.pt",
# request_method="GET")
# config.add_view("lembrar.views.edit.edit_post", route_name="edit",
# request_method="POST")
config.add_static_view("", "lembrar:static")
config.add_subscriber(add_base_template, "pyramid.events.BeforeRender")
# MongoDB
def add_mongo_db(event):
settings = event.request.registry.settings
db_name = settings["mongodb_db"]
db = settings["mongodb_conn"][db_name]
event.request.db = db
db_uri = settings["mongodb_dsn"]
conn = pymongo.Connection(db_uri)
config.registry.settings["mongodb_conn"] = conn
db = conn[config.registry.settings["mongodb_db"]]
db.authenticate(config.registry.settings['mongodb_user'],
config.registry.settings['mongodb_password'])
db.docs.ensure_index("created")
config.add_subscriber(add_mongo_db, NewRequest)
# registry
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
css = webassets.Bundle('bootstrap.min.css',
webassets.Bundle('styles.css', filters='yui_css'),
output='bundle.min.css')
config.add_webasset('css', css)
config.registry.settings['webassets_env'] = config.get_webassets_env()
config.add_subscriber(add_webassets_env, NewRequest)
db_uri = settings['mongodb.db_uri']
conn = pymongo.Connection(db_uri)
config.registry.settings['db_conn'] = conn
try:
if asbool(settings.get('nurl.check_whitelist', False)):
with open(os.path.join(APP_PATH, '..',
'whitelist.txt')) as whitelist:
config.registry.settings['nurl.whitelist'] = get_whitelist(
whitelist,
asbool(settings.get('nurl.check_whitelist_auto_www',
False)))
except IOError:
config.registry.settings['nurl.check_whitelist'] = False
config.add_subscriber(add_mongo_db, NewRequest)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('shortened', '/{short_ref}')
#rest api version 1
config.add_route('shortener_v1', '/api/v1/shorten')
config.scan()
application = config.make_wsgi_app()
#newrelic agent
try:
if asbool(settings.get('newrelic.enable', False)):
newrelic.agent.initialize(
os.path.join(APP_PATH, '..', 'newrelic.ini'),
settings['newrelic.environment'])
return newrelic.agent.wsgi_application()(application)
else:
return application
except IOError:
config.registry.settings['newrelic.enable'] = False
return application
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
with Configurator(settings=settings) as config:
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.include('pyramid_jinja2')
config.include('.routes')
config.include('.database')
config.include('.callbacks')
config.scan()
return config.make_wsgi_app()
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp()
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.authn_policy = AuthTktAuthenticationPolicy('$3kr1t')
self.config.set_authentication_policy(self.authn_policy)
self.config.scan("cornice.tests.test_resource")
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def configure_application(config):
"""
Configure `sandglass.time` application.
"""
config.add_translation_dirs('sandglass.time:locales/')
config.include('sandglass.time.resource')
json_renderer = JSONP(param_name='callback')
json_renderer.add_adapter(datetime.datetime, json_datetime_adapter)
config.add_renderer('json', json_renderer)
# Add custom request methods
extend_request_object(config)
# Scan modules that need to be pre-loaded
config.scan('sandglass.time.models')
config.scan('sandglass.time.errorhandlers')
# Attach sandglass.time resources to '/time' URL path prefix
config.include(include_resources, route_prefix='time')
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.include('pyramid_tm')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('org', '/org')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
[1]: This views are responding for requests with any methods except GET,
so have a work-around with multiple routes path to attend with or without trailing slash.
Reference:
http://docs.pylonsproject.org/projects/pyramid/en/latest/narr/urldispatch.html#redirecting-to-slash-appended-routes
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
db_dsn = os.environ.get('MONGODB_HOST',
settings.get('mongo_uri', '127.0.0.1:27017'))
db_client = controller.get_dbconn(db_dsn)
def add_databroker(request):
"""Add a databroker to all incoming request"""
return controller.DataBroker(db_client)
config.add_route('index', '/')
# collections - GET method:
config.add_route('collection', '/api/v1/collection/')
config.add_route('identifiers_collection',
'/api/v1/collection/identifiers/')
# journals - GET method:
config.add_route('journal', '/api/v1/journal/')
config.add_route('identifiers_journal', '/api/v1/journal/identifiers/')
config.add_route('exists_journal', '/api/v1/journal/exists/')
# issues - GET method:
config.add_route('get_issue', '/api/v1/issue/')
config.add_route('get_issues', '/api/v1/issues/')
config.add_route('identifiers_issue', '/api/v1/issue/identifiers/')
config.add_route('exists_issue', '/api/v1/issue/exists/')
# articles - GET method:
config.add_route('get_article', '/api/v1/article/')
config.add_route('get_articles', '/api/v1/articles/')
config.add_route('identifiers_article', '/api/v1/article/identifiers/')
config.add_route('exists_article', '/api/v1/article/exists/')
# press releases - GET method:
config.add_route('identifiers_press_release',
'/api/v1/press_release/identifiers/')
# logs historychanges - GET method:
config.add_route('list_historychanges_article', '/api/v1/article/history/')
config.add_route('list_historychanges_journal', '/api/v1/journal/history/')
config.add_route('list_historychanges_issue', '/api/v1/issue/history/')
# others
config.add_request_method(add_databroker, 'databroker', reify=True)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('files', XML_FILES, cache_max_age=3600)
config.add_route('home', '/')
config.add_route('packages', '/packages')
config.add_route('editor', '/editor')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
def add_controller(request):
es = os.environ.get(
'ELASTICSEARCH_HOST',
settings.get('elasticsearch_host', '127.0.0.1:9200'))
es_index = os.environ.get(
'ELASTICSEARCH_INDEX',
settings.get('elasticsearch_index', 'citations'))
return controller.controller(aslist(es),
sniff_on_connection_fail=True,
timeout=600).set_base_index(es_index)
config.add_route('index', '/')
config.add_route('status', '/_status/')
config.add_route('citedby_pid', '/api/v1/pid/')
config.add_route('citedby_doi', '/api/v1/doi/')
config.add_route('citedby_meta', '/api/v1/meta/')
config.add_request_method(add_controller, 'controller', reify=True)
# Cache Settings Config
memcached_host = os.environ.get('MEMCACHED_HOST',
settings.get('memcached_host', None))
memcached_expiration_time = os.environ.get(
'MEMCACHED_EXPIRATION_TIME',
settings.get('memcached_expiration_time', 2592000) # a month cache
)
if 'memcached_host' is not None:
cache_config = {}
cache_config['expiration_time'] = int(memcached_expiration_time)
cache_config['arguments'] = {'url': memcached_host, 'binary': True}
controller_cache_region.configure('dogpile.cache.pylibmc',
**cache_config)
else:
controller_cache_region.configure('dogpile.cache.null')
config.scan()
return config.make_wsgi_app()
def _register_common_templates(config):
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.include('pyramid_jinja2')
env = config.get_jinja2_environment()
env.filters['skipautoescape'] = skipautoescape
env.filters['jsonify'] = jsonify
config.add_view('flow.site.views.errors.http404',
renderer='flow:templates/http404.jinja2',
context='pyramid.exceptions.NotFound')
config.testing_add_renderer('templates/login.jinja2')
config.testing_add_renderer('templates/toolbar.jinja2')
config.testing_add_renderer('templates/cloud.jinja2')
config.testing_add_renderer('templates/latest.jinja2')
config.testing_add_renderer('templates/sparql_query.jinja2')
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp(autocommit=False)
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
add_view(UserImp.get, renderer='json')
add_view(UserImp.get, renderer='jsonp')
add_view(UserImp.collection_post, renderer='json', accept='text/json')
user_resource = add_resource(UserImp,
collection_path='/users',
path='/users/{id}',
name='user_service',
factory=dummy_factory)
self.config.add_cornice_resource(user_resource)
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
}
meta = MetadataSchema().serialize(obj.__dict__)
# FIXME in_navigation is serialized as string instead of bool
meta['in_navigation'] = bools[meta['in_navigation'].lower()]
if include_messages:
meta['messages'] = get_messages(request)
if relmeta:
# make data.relationships.meta object
rel = dict()
relmeta = dict()
rel['meta'] = relational_metadata(obj, request)
res['relationships'] = rel
return dict(data=res, meta=meta)
jsonp = JSONP(param_name='callback')
jsonp.add_adapter(Content, serialize)
jsonp.add_adapter(colander._null, lambda obj, req: None)
jsonp.add_adapter(datetime.date, lambda obj, req: str(obj))
jsonp.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat())
jsonp.add_adapter(datetime.time, lambda obj, req: str(obj))
contents_jsonp = JSONP(param_name='callback')
def includeme(config):
config.add_renderer('kotti_jsonp', jsonp)
config.scan(__name__)
def includeme(config):
"""Upgrading:
- register utilities "by hand", after config.include('clld.web.app')
- add routes by hand (and remove these from the **kw passed to Configurator)
:param config:
:return:
"""
#
# now we exploit the default package layout as created via the CLLD scaffold:
#
# note: the following exploits the import time side effect of modifying the webassets
# environment!
root_package = config.root_package.__name__
maybe_import('%s.assets' % root_package)
pkg_dir = Path(config.root_package.__file__).parent.resolve()
json_renderer = JSON()
json_renderer.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat())
json_renderer.add_adapter(datetime.date, lambda obj, req: obj.isoformat())
config.add_renderer('json', json_renderer)
jsonp_renderer = JSONP(param_name='callback')
jsonp_renderer.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat())
jsonp_renderer.add_adapter(datetime.date, lambda obj, req: obj.isoformat())
config.add_renderer('jsonp', jsonp_renderer)
config.set_request_factory(ClldRequest)
config.registry.registerUtility(CtxFactoryQuery(), interfaces.ICtxFactoryQuery)
config.registry.registerUtility(OlacConfig(), interfaces.IOlacConfig)
# initialize the db connection
engine = engine_from_config(config.registry.settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config.add_settings({
'pyramid.default_locale_name': 'en',
'clld.pkg': root_package,
'clld.parameters': {}})
if 'clld.files' in config.registry.settings:
# deployment-specific location of static data files
abspath = Path(config.registry.settings['clld.files']).resolve()
config.add_settings({'clld.files': abspath})
config.add_static_view('files', abspath.as_posix())
# event subscribers:
config.add_subscriber(add_localizer, events.NewRequest)
config.add_subscriber(init_map, events.ContextFound)
config.add_subscriber(
partial(add_renderer_globals, maybe_import('%s.util' % root_package)),
events.BeforeRender)
#
# make it easy to register custom functionality
#
for name, func in {
'register_datatable': partial(register_cls, interfaces.IDataTable),
'register_map': partial(register_cls, interfaces.IMap),
'register_menu': register_menu,
'register_resource': register_resource,
'register_adapter': register_adapter,
'register_adapters': register_adapters,
'register_download': register_download,
'register_staticresource': register_staticresource,
'add_route_and_view': add_route_and_view,
'add_settings_from_file': add_settings_from_file,
'add_301': add_301,
'add_410': add_410,
'add_page': add_page,
'register_resource_routes_and_views': register_resource_routes_and_views,
}.items():
config.add_directive(name, func)
#
# routes and views
#
config.add_static_view('clld-static', 'clld:web/static')
config.add_static_view('static', '%s:static' % root_package)
config.add_route_and_view('_js', '/_js', js, http_cache=3600)
# add some maintenance hatches
config.add_route_and_view('_raise', '/_raise', _raise)
config.add_route_and_view('_ping', '/_ping', _ping, renderer='json')
# sitemap support:
config.add_route_and_view('robots', '/robots.txt', robots)
config.add_route_and_view('sitemapindex', '/sitemap.xml', sitemapindex)
config.add_route_and_view('sitemap', '/sitemap.{rsc}.{n}.xml', sitemap)
config.add_route('resourcemap', '/resourcemap.json')
config.add_view(resourcemap, route_name='resourcemap', renderer='jsonp')
config.add_route_and_view(
'select_combination', '/_select_combination', select_combination)
config.add_route_and_view('unapi', '/unapi', unapi)
config.add_route_and_view('olac', '/olac', olac)
config.add_settings_from_file(pkg_dir.joinpath('appconf.ini'))
if not config.registry.settings.get('mako.directories'):
config.add_settings({'mako.directories': ['clld:web/templates']})
for rsc in RESOURCES:
config.register_resource_routes_and_views(rsc)
config.register_datatable(
rsc.plural, getattr(datatables, rsc.plural.capitalize(), DataTable))
register_resource_adapters(config, rsc)
# maps
config.register_map('languages', Map)
config.register_map('language', LanguageMap)
config.register_map('parameter', ParameterMap)
config.register_map('combination', CombinationMap)
config.include('clld.web.adapters')
for icon in ICONS:
config.registry.registerUtility(icon, interfaces.IIcon, name=icon.name)
config.registry.registerUtility(ORDERED_ICONS, interfaces.IIconList)
config.registry.registerUtility(MapMarker(), interfaces.IMapMarker)
#
# inspect default locations for views and templates:
#
home_comp = OrderedDict()
for name, template in [
('introduction', False),
('about', False),
('terms', False),
('glossary', False),
('history', False),
('changes', False),
('credits', False),
('legal', True),
('download', True),
('contact', True),
('help', False),
]:
home_comp[name] = template
if pkg_dir.joinpath('templates').exists():
for p in pkg_dir.joinpath('templates').iterdir():
if p.stem in home_comp and p.suffix == '.mako':
home_comp[p.stem] = True
for name, template in home_comp.items():
if template:
config.add_page(name)
config.add_settings({'home_comp': [k for k in home_comp.keys() if home_comp[k]]})
if 'clld.favicon' not in config.registry.settings:
favicon = {'clld.favicon': 'clld:web/static/images/favicon.ico'}
# hard to test (in particular on travis) and without too much consequence
# (and the consequences faced are easy to spot).
if pkg_dir.joinpath('static', 'favicon.ico').exists(): # pragma: no cover
favicon['clld.favicon'] = root_package + ':static/favicon.ico'
config.add_settings(favicon)
with open(abspath_from_asset_spec(
config.registry.settings['clld.favicon']), mode='rb') as fp:
fh = md5()
fh.update(fp.read())
config.add_settings({'clld.favicon_hash': fh.hexdigest()})
translation_dirs = ['clld:locale']
if pkg_dir.joinpath('locale').exists():
translation_dirs.append('%s:locale' % root_package) # pragma: no cover
config.add_translation_dirs(*translation_dirs)
if pkg_dir.joinpath('static/publisher_logo.png').exists(): # pragma: no cover
config.add_settings(
{'clld.publisher_logo': '%s:static/publisher_logo.png' % root_package})
if asbool(config.registry.settings.get('clld.pacific_centered_maps')):
geojson.pacific_centered()
v = maybe_import('%s.views' % root_package)
if v:
config.scan(v) # pragma: no cover
menuitems = config.registry.settings.get(
'clld.menuitems_list',
['contributions', 'parameters', 'languages', 'contributors'])
config.register_menu(('dataset', dict(label='Home')), *menuitems)
config.include('pyramid_mako')
for name in ['adapters', 'datatables', 'maps']:
mod = maybe_import('%s.%s' % (root_package, name))
if mod and hasattr(mod, 'includeme'):
config.include(mod)
config.register_download(CldfDownload(common.Dataset, root_package))
class Encoder(json.JSONEncoder):
def default(self, obj):
"""Convert ``obj`` to something JSON encoder can handle."""
# if isinstance(obj, NamedTuple):
# obj = dict((k, getattr(obj, k)) for k in obj.keys())
if isinstance(obj, decimal.Decimal):
return str(obj)
elif isinstance(obj, datetime_types):
return str(obj)
elif obj is colander.null:
return None
return basedefault(obj)
return Encoder
def to_json(obj, default=None, **kw):
return json.dumps(obj, cls=_encoder(default), **kw)
jsonp = JSONP(param_name='callback', serializer=to_json)
jsonp.add_adapter(Content, serialize)
def includeme(config):
config.add_renderer('kotti_jsonp', jsonp)
config.scan(__name__)
def get_configurator(pkg, *utilities, **kw):
"""
.. seealso:: https://groups.google.com/d/msg/pylons-discuss/Od6qIGaLV6A/3mXVBQ13zWQJ
"""
kw.setdefault('package', pkg)
routes = kw.pop('routes', [])
config = Configurator(**kw)
json_renderer = JSON()
json_renderer.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat())
json_renderer.add_adapter(datetime.date, lambda obj, req: obj.isoformat())
config.add_renderer('json', json_renderer)
jsonp_renderer = JSONP(param_name='callback')
jsonp_renderer.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat())
jsonp_renderer.add_adapter(datetime.date, lambda obj, req: obj.isoformat())
config.add_renderer('jsonp', jsonp_renderer)
for name, pattern in routes:
config.add_route(name, pattern)
config.set_request_factory(ClldRequest)
config.registry.registerUtility(CtxFactoryQuery(), interfaces.ICtxFactoryQuery)
config.registry.registerUtility(OlacConfig(), interfaces.IOlacConfig)
# initialize the db connection
engine = engine_from_config(config.registry.settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config.add_settings({
'pyramid.default_locale_name': 'en',
'clld.pkg': config.package_name,
'clld.parameters': {}})
if 'clld.files' in config.registry.settings:
# deployment-specific location of static data files
abspath = path(config.registry.settings['clld.files']).abspath()
config.add_settings({'clld.files': abspath})
config.add_static_view('files', abspath)
# event subscribers:
config.add_subscriber(add_localizer, events.NewRequest)
config.add_subscriber(init_map, events.ContextFound)
config.add_subscriber(
partial(add_renderer_globals, maybe_import('%s.util' % config.package_name)),
events.BeforeRender)
#
# make it easy to register custom functionality
#
for name, func in {
'register_datatable': partial(register_cls, interfaces.IDataTable),
'register_map': partial(register_cls, interfaces.IMap),
'register_menu': register_menu,
'register_resource': register_resource,
'register_adapter': register_adapter,
'register_download': register_download,
'add_route_and_view': add_route_and_view,
'add_settings_from_file': add_settings_from_file,
'add_301': add_301,
'add_410': add_410,
}.items():
config.add_directive(name, func)
#
# routes and views
#
config.add_static_view('clld-static', 'clld:web/static')
config.add_static_view('static', '%s:static' % config.package_name)
config.add_route_and_view('_js', '/_js', js, http_cache=3600)
# add some maintenance hatches
config.add_route_and_view('_raise', '/_raise', _raise)
config.add_route_and_view('_ping', '/_ping', _ping, renderer='json')
# sitemap support:
config.add_route_and_view('robots', '/robots.txt', robots)
config.add_route_and_view('sitemapindex', '/sitemap.xml', sitemapindex)
config.add_route_and_view('sitemap', '/sitemap.{rsc}.{n}.xml', sitemap)
config.add_route('resourcemap', '/resourcemap.json')
config.add_view(resourcemap, route_name='resourcemap', renderer='jsonp')
config.add_route_and_view(
'select_combination', '/_select_combination', select_combination)
# TODO: remove google site verification for personal account! should be configurable!
config.add_route('google-site-verification', 'googlebbc8f4da1abdc58b.html')
config.add_view(
lambda r: Response('google-site-verification: googlebbc8f4da1abdc58b.html'),
route_name='google-site-verification')
config.add_route_and_view('unapi', '/unapi', unapi)
config.add_route_and_view('olac', '/olac', olac)
for rsc in RESOURCES:
name, model = rsc.name, rsc.model
factory = partial(ctx_factory, model, 'index')
config.add_route_and_view(
rsc.plural, '/%s' % rsc.plural, index_view, factory=factory)
config.register_datatable(
rsc.plural, getattr(datatables, rsc.plural.capitalize(), DataTable))
config.register_adapter(
getattr(excel, rsc.plural.capitalize(), excel.ExcelAdapter), rsc.interface)
kw = dict(factory=partial(ctx_factory, model, 'rsc'))
if model == common.Dataset:
pattern = '/'
kw['alt_route_pattern'] = '/void.{ext}'
else:
pattern = '/%s/{id:[^/\.]+}' % rsc.plural
config.add_route_and_view(name, pattern, resource_view, **kw)
# maps
config.register_map('languages', Map)
config.register_map('language', LanguageMap)
config.register_map('parameter', ParameterMap)
config.register_map('combination', CombinationMap)
config.include('clld.web.adapters')
for icon in ICONS:
config.registry.registerUtility(icon, interfaces.IIcon, name=icon.name)
config.registry.registerUtility(MapMarker(), interfaces.IMapMarker)
#
# now we exploit the default package layout as created via the CLLD scaffold:
#
# note: the following exploits the import time side effect of modifying the webassets
# environment!
maybe_import('%s.assets' % config.package_name)
pkg_dir = path(config.package.__file__).dirname().abspath()
#
# inspect default locations for views and templates:
#
home_comp = OrderedDict()
for name, template in [
('introduction', False),
('about', False),
('terms', False),
('glossary', False),
('history', False),
('changes', False),
('credits', False),
('legal', True),
('download', True),
('contact', True),
('help', False),
]:
home_comp[name] = template
if pkg_dir.joinpath('templates').exists():
for p in pkg_dir.joinpath('templates').files():
if p.namebase in home_comp and p.ext == '.mako':
home_comp[p.namebase] = True
views = maybe_import('%s.views' % config.package_name)
for name, template in home_comp.items():
if template:
config.add_route_and_view(
name,
'/' + name,
getattr(views, name, lambda r: {}),
renderer=name + '.mako')
config.add_settings({'home_comp': [k for k in home_comp.keys() if home_comp[k]]})
if 'clld.favicon' not in config.registry.settings:
favicon = {'clld.favicon': 'clld:web/static/images/favicon.ico'}
# hard to test (in particular on travis) and without too much consequence
# (and the consequences faced are easy to spot).
if pkg_dir.joinpath('static', 'favicon.ico').exists(): # pragma: no cover
favicon['clld.favicon'] = config.package_name + ':static/favicon.ico'
config.add_settings(favicon)
with open(abspath_from_asset_spec(config.registry.settings['clld.favicon'])) as fp:
fh = md5()
fh.update(fp.read())
config.add_settings({'clld.favicon_hash': fh.hexdigest()})
if pkg_dir.joinpath('locale').exists():
config.add_translation_dirs('clld:locale', '%s:locale' % config.package_name)
if pkg_dir.joinpath('static/publisher_logo.png').exists(): # pragma: no cover
config.add_settings(
{'clld.publisher_logo': '%s:static/publisher_logo.png' % config.package_name})
config.add_settings_from_file(pkg_dir.joinpath('appconf.ini'))
v = maybe_import('%s.views' % config.package_name)
if v:
config.scan(v) # pragma: no cover
menuitems = OrderedDict(dataset=partial(menu_item, 'dataset', label='Home'))
for plural in config.registry.settings.get(
'clld.menuitems_list',
['contributions', 'parameters', 'languages', 'contributors']
):
menuitems[plural] = partial(menu_item, plural)
config.registry.registerUtility(menuitems, interfaces.IMenuItems)
config.include('pyramid_mako')
for utility, interface in utilities:
config.registry.registerUtility(utility, interface)
return config
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# setup the database engine
engine = engine_from_config(settings, 'sqlalchemy.', pool_size=5)
sqlahelper.add_engine(engine)
# initialize database structures
initialize_db(engine)
# set up beaker cache
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory=ACLFactory)
# mako for templating
config.include('pyramid_mako')
# Mozilla Persona as the login verifier. It defines default
# authentication and authorization policies.
config.include('pyramid_persona')
# override the authn policy to provide a callback
secret = settings.get('persona.secret', None)
authn_policy = AuthTktAuthenticationPolicy(secret, callback=groupfinder, hashalg='sha512')
config.set_authentication_policy(authn_policy)
# for json-encoded responses
def datetime_timedelta_adapter(obj, request):
return obj.seconds;
def datetime_datetime_adapter(obj, request):
return obj.isoformat();
def decimal_adapter(obj, request):
return float(obj);
jsonp = JSONP(param_name='callback')
jsonp.add_adapter(datetime.timedelta, datetime_timedelta_adapter)
jsonp.add_adapter(datetime.datetime, datetime_datetime_adapter)
jsonp.add_adapter(Decimal, decimal_adapter)
config.add_renderer('jsonp', jsonp)
# for static assets
config.add_static_view('static', 'xonstat:static')
# robots
config.add_route("robots", "robots.txt")
config.add_view(robots, route_name="robots")
# for 404s
config.add_view(notfound, context=HTTPNotFound, renderer="404.mako")
# ROOT ROUTE
config.add_route("main_index", "/")
config.add_view(main_index, route_name="main_index", renderer="main_index.mako")
config.add_route("cookies", "/cookies");
config.add_view(cookie_policy, route_name="cookies", renderer="cookies.mako");
config.add_route("recent_games_json", "/recentgames.json")
config.add_view(recent_games_json, route_name="recent_games_json", renderer="jsonp")
config.add_route("top_servers_json", "/topservers.json")
config.add_view(top_servers_json, route_name="top_servers_json", renderer="jsonp")
config.add_route("top_maps_json", "/topmaps.json")
config.add_view(top_maps_json, route_name="top_maps_json", renderer="jsonp")
config.add_route("news_index", "/news")
config.add_view(news_index, route_name="news_index", renderer="news_index.mako")
config.add_route("forum_index", "/forum")
config.add_view(news_index, route_name="forum_index", renderer="news_index.mako")
# MAIN SUBMISSION ROUTE
config.add_route("submit_stats", "stats/submit")
config.add_view(submit_stats, route_name="submit_stats", renderer="jsonp")
# PLAYER ROUTES
config.add_route("player_game_index", "/player/{player_id:\d+}/games")
config.add_view(player_game_index, route_name="player_game_index", renderer="player_game_index.mako")
config.add_route("player_game_index_json", "/player/{player_id:\d+}/games.json")
config.add_view(player_game_index_json, route_name="player_game_index_json", renderer="jsonp")
config.add_route("player_info", "/player/{id:\d+}")
config.add_view(player_info, route_name="player_info", renderer="player_info.mako")
config.add_route("player_info_json", "/player/{id:\d+}.json")
config.add_view(player_info_json, route_name="player_info_json", renderer="jsonp")
config.add_route("player_hashkey_info_text", "/player/me")
config.add_view(player_hashkey_info_text, route_name="player_hashkey_info_text", renderer="player_hashkey_info_text.mako")
config.add_route("player_hashkey_info_json", "/player/me.json")
config.add_view(player_hashkey_info_json, route_name="player_hashkey_info_json", renderer="jsonp")
config.add_route("player_elo_info_text", "/player/{hashkey}/elo.txt")
config.add_view(player_elo_info_text, route_name="player_elo_info_text", renderer="player_elo_info_text.mako")
config.add_route("players_elo", "/elo/{hashkeys}");
config.add_view(players_elo, route_name="players_elo", renderer="jsonp")
config.add_route("players_elo_b", "/elo_b/{hashkeys}");
config.add_view(players_elo_b, route_name="players_elo_b", renderer="jsonp")
config.add_route("players_glicko", "/glicko/{hashkeys}");
config.add_view(players_glicko, route_name="players_glicko", renderer="jsonp")
config.add_route("players_aliases_json", "/aliases/{hashkeys}.json");
config.add_view(players_aliases_json, route_name="players_aliases_json", renderer="jsonp")
config.add_route("players_aliases_text", "/aliases/{hashkeys}");
config.add_view(players_aliases_text, route_name="players_aliases_text", renderer="players_aliases_text.mako")
config.add_route("player_recent_games_json", "/player/{id:\d+}/recent_games.json");
config.add_view(player_recent_games_json, route_name="player_recent_games_json", renderer="jsonp");
# FIXME - needs an additional method to convert to JSON
config.add_route("player_elo_info_json", "/player/{hashkey}/elo.json")
config.add_view(player_elo_info_json, route_name="player_elo_info_json", renderer="jsonp")
config.add_route("player_accuracy", "/player/{id:\d+}/accuracy")
config.add_view(player_accuracy_json, route_name="player_accuracy", renderer="jsonp")
config.add_route("player_index", "/players")
config.add_view(player_index, route_name="player_index", renderer="player_index.mako")
config.add_route("player_index_json", "/players.json")
config.add_view(player_index_json, route_name="player_index_json", renderer="jsonp")
config.add_route("player_captimes", "/player/{player_id:\d+}/captimes")
config.add_view(player_captimes, route_name="player_captimes", renderer="player_captimes.mako")
config.add_route("player_captimes_json", "/player/{player_id:\d+}/captimes.json")
config.add_view(player_captimes_json, route_name="player_captimes_json", renderer="jsonp")
config.add_route("player_weaponstats_data_json", "/player/{id:\d+}/weaponstats.json")
config.add_view(player_weaponstats_data_json, route_name="player_weaponstats_data_json", renderer="jsonp")
config.add_route("top_players_by_time", "/topactive")
config.add_view(top_players_by_time, route_name="top_players_by_time", renderer="top_players_by_time.mako")
config.add_route("top_servers_by_players", "/topservers")
config.add_view(top_servers_by_players, route_name="top_servers_by_players", renderer="top_servers_by_players.mako")
config.add_route("top_maps_by_times_played", "/topmaps")
config.add_view(top_maps_by_times_played, route_name="top_maps_by_times_played", renderer="top_maps_by_times_played.mako")
# GAME ROUTES
config.add_route("game_info", "/game/{id:\d+|[0-9a-fA-F]+-[0-9a-fA-F\-]+}")
config.add_view(game_info, route_name="game_info", renderer="game_info.mako")
config.add_route("game_info_json", "/game/{id:\d+}.json")
config.add_view(game_info_json, route_name="game_info_json", renderer="jsonp")
config.add_route("rank_index0", "/ranks/{game_type_cd:ctf|ffa|tdm|duel|ca|ft|race|rr|ad}")
config.add_view(rank_index, route_name="rank_index0", renderer="rank_index.mako")
config.add_route("rank_index", "/ranks/{game_type_cd:ctf|ffa|tdm|duel|ca|ft|race|rr|ad}/{region:\d+}")
config.add_view(rank_index, route_name="rank_index", renderer="rank_index.mako")
config.add_route("rank_index_json0", "/ranks/{game_type_cd:ctf|ffa|tdm|duel|ca|ft|race|rr|ad}.json")
config.add_view(rank_index_json, route_name="rank_index_json0", renderer="jsonp")
config.add_route("rank_index_json", "/ranks/{game_type_cd:ctf|ffa|tdm|duel|ca|ft|race|rr|ad}/{region:\d+}.json")
config.add_view(rank_index_json, route_name="rank_index_json", renderer="jsonp")
config.add_route("game_index", "/games")
config.add_view(game_finder, route_name="game_index", renderer="game_finder.mako")
# SERVER ROUTES
config.add_route("server_index", "/servers")
config.add_view(server_index, route_name="server_index", renderer="server_index.mako")
config.add_route("server_index_json", "/servers.json")
config.add_view(server_index_json, route_name="server_index_json", renderer="jsonp")
config.add_route("server_game_index", "/server/{server_id:\d+}/games/page/{page:\d+}")
config.add_view(server_game_index, route_name="server_game_index", renderer="server_game_index.mako")
config.add_route("server_game_index_json", "/server/{server_id:\d+}/games.json")
config.add_view(server_game_index_json, route_name="server_game_index_json", renderer="jsonp")
config.add_route("server_info", "/server/{id:\d+|.+\..+:\d+}")
config.add_view(server_info, route_name="server_info", renderer="server_info.mako")
config.add_route("server_info_json", "/server/{id:\d+|.+\..+:\d+}.json")
config.add_view(server_info_json, route_name="server_info_json", renderer="jsonp")
# MAP ROUTES
config.add_route("map_index", "/maps")
config.add_view(map_index, route_name="map_index", renderer="map_index.mako")
config.add_route("map_index_json", "/maps.json")
config.add_view(map_index_json, route_name="map_index_json", renderer="jsonp")
config.add_route("map_info", "/map/{id}")
config.add_view(map_info, route_name="map_info", renderer="map_info.mako")
config.add_route("map_info_json", "/map/{id:\d+}.json")
config.add_view(map_info_json, route_name="map_info_json", renderer="jsonp")
config.add_route("map_captimes", "/map/{id:\d+}/captimes")
config.add_view(map_captimes, route_name="map_captimes", renderer="map_captimes.mako")
config.add_route("map_captimes_json", "/map/{id:\d+}/captimes.json")
config.add_view(map_captimes_json, route_name="map_captimes_json", renderer="jsonp")
# SEARCH ROUTES
config.add_route("search", "search")
config.add_view(search, route_name="search", renderer="search.mako")
config.add_route("search_json", "search.json")
config.add_view(search_json, route_name="search_json", renderer="jsonp")
# ADMIN ROUTES
config.add_forbidden_view(forbidden, renderer="forbidden.mako")
config.add_route("login", "/login")
config.add_view(login, route_name="login", check_csrf=True, renderer="json")
config.add_route("merge", "/admin/merge")
config.add_view(merge, route_name="merge", renderer="merge.mako", permission="merge")
return config.make_wsgi_app()
