def _makeOne(self, autocommit=True):
from pyramid.config import Configurator
import pyramid_handlers
from papyrus import add_papyrus_routes
config = Configurator(autocommit=autocommit)
config.add_directive('add_papyrus_routes', add_papyrus_routes)
return config
def _makeOne(self, autocommit=True):
from pyramid.config import Configurator
from pyramid_handlers import add_handler
config = Configurator(autocommit=autocommit)
config.add_directive("add_handler", add_handler)
return config
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
config = Configurator(settings=settings)
config.include('pyramid_handlers')
config.include('pyramid_jinja2')
config.include('pyramid_mailer')
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.add_directive('add_magic_handler', add_magic_handler)
config.add_subscriber(add_renderer_globals, BeforeRender)
config.add_static_view('statics', 'blog:statics')
# Home route
config.add_handler('home', get_route(), get_handler('blog'), 'index')
# Custom routes
# Index/Action routes
config.add_magic_handler('user')
config.add_magic_handler('post')
config.add_magic_handler('tag')
return config.make_wsgi_app()
def main(global_config, **settings):
## Prepare database
engine = engine_from_config(settings, 'sqlalchemy.')
db.session.configure(bind=engine)
db.Base.metadata.bind = engine
#
# FIXME: Pyramid whines about no configured authorization policy, probably
# because we didn't set authn policy using the Configurator initializer.
authz_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
root_factory=Root,
request_factory=RequestFactory,
authorization_policy=authz_policy,
)
# Expose the authorization policy through requests.
config.add_request_method(lambda x: authz_policy, "authz", reify=True)
# Add a configurator method to add new nodes to the root factory
config.add_directive("add_root_node", Root.add_node, action_wrap=False)
# Provide a short-hand method for testing permissions.
config.add_request_method(request_test_permission, "permits")
## Load and configure all views
for path in settings['perpetualfailure.modules'].split("\n"):
module = __import__(path, fromlist=[path])
module.configure(config)
config.scan(module)
#
return config.make_wsgi_app()
def _makeOne(self, autocommit=True):
from pyramid.config import Configurator
import pyramid_handlers
from papyrus import add_papyrus_routes
config = Configurator(autocommit=autocommit)
config.add_directive('add_papyrus_routes', add_papyrus_routes)
return config
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
globalreg = getGlobalSiteManager()
set_cache_regions_from_settings(settings)
deserialized_settings = deserialize(settings)
config = Configurator(registry=globalreg)
config.setup_registry(settings=settings)
config.registry.registerUtility(
deserialized_settings,
ISettings,
name='settings'
)
config.add_directive('settings_reader', lambda c: SettingsReader(c))
config.reader = SettingsReader(config)
config.include('papaye.config.auth')
config.include('papaye.config.routes')
config.include('papaye.config.views')
config.include('papaye.config.startup')
config.add_renderer(
name='json_api_compat',
factory='papaye.views.api.compat.renderers.CompatAPIRendererFactory'
)
config.commit()
config.add_tween('papaye.tweens.LoginRequiredTweenFactory')
config.scan(ignore=['papaye.tests', 'papaye.conftest'])
config.set_request_property(
lambda x: deserialized_settings,
'papaye_settings',
reify=True
)
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_directive('add_restful_routes', routing.add_restful_routes)
set_globals(**settings)
from . import config as global_config
secret = str(uuid.uuid4())
# Beaker include
config.include('pyramid_beaker')
if global_config.AUTH_ENABLED is True:
authn_policy = AuthTktAuthenticationPolicy(secret,
callback=model.user_callback, hashalg='sha512', include_ip=global_config.AUTH_INCLUDE_IP)
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
model.make_restful_app()
routing.make_routes(config)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
settings["g"] = g = Globals(**settings)
config = Configurator(
settings=settings,
root_factory=WebsiteRootContext,
session_factory=session_factory_from_settings(settings),
authentication_policy=Security(),
authorization_policy=ACLAuthorizationPolicy(),
default_permission='view')
request.extend_request_traversal(config)
config.add_directive('add_mako_renderer', pyramid_mako.add_mako_renderer)
config.add_mako_renderer(".html")
config.add_mako_renderer(".xml")
config.add_renderer('json', jsonRenderer)
def _(request, string):
return string
config.add_request_method(_, '_')
config.add_subscriber(add_renderer_variables,
'pyramid.events.BeforeRender')
config.include("ufostart.handlers")
config.include("ufostart.admin")
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_directive('add_restful_routes', routing.add_restful_routes)
set_globals(**settings)
from . import config as global_config
secret = str(uuid.uuid4())
# Beaker include
config.include('pyramid_beaker')
if global_config.AUTH_ENABLED is True:
authn_policy = AuthTktAuthenticationPolicy(
secret,
callback=model.user_callback,
hashalg='sha512',
include_ip=global_config.AUTH_INCLUDE_IP)
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
model.make_restful_app()
routing.make_routes(config)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
settings["g"] = g = Globals(**settings)
config = Configurator(settings=settings
, root_factory=WebsiteRootContext
, session_factory = session_factory_from_settings(settings)
, authentication_policy= Security()
, authorization_policy= ACLAuthorizationPolicy()
, default_permission='view'
)
request.extend_request_traversal(config)
config.add_directive('add_mako_renderer', pyramid_mako.add_mako_renderer)
config.add_mako_renderer(".html")
config.add_mako_renderer(".xml")
config.add_renderer('json', jsonRenderer)
def _(request, string):
return string
config.add_request_method(_, '_')
config.add_subscriber(add_renderer_variables, 'pyramid.events.BeforeRender')
config.include("ufostart.handlers")
config.include("ufostart.admin")
config.scan()
return config.make_wsgi_app()
def _makeOne(self, autocommit=True):
from pyramid.config import Configurator
import pyramid_handlers
from papyrus import add_papyrus_handler
config = Configurator(autocommit=autocommit)
config.include(pyramid_handlers)
config.add_directive("add_papyrus_handler", add_papyrus_handler)
return config
def includeme(config: Configurator):
def set_authorization_policy(config: Configurator, policy: Any) -> None:
policy = config.maybe_dotted(policy)
if isinstance(policy, INewAuthorizationPolicy):
policy = AuthorizationPolicyWrapper(policy)
# noinspection PyCallByClass
SecurityConfiguratorMixin.set_authorization_policy(config, policy)
config.add_directive('set_authorization_policy', set_authorization_policy)
def includeme(config: Configurator):
def set_authorization_policy(config: Configurator, policy: Any) -> None:
policy = config.maybe_dotted(policy)
if isinstance(policy, INewAuthorizationPolicy):
policy = AuthorizationPolicyWrapper(policy)
# noinspection PyCallByClass
SecurityConfiguratorMixin.set_authorization_policy(config, policy)
config.add_directive('set_authorization_policy', set_authorization_policy)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
mem_profiler = asbool(settings.get('mem_profiler', 'False'))
settings['mem_profiler'] = mem_profiler
perf_profiler = asbool(settings.get('perf_profiler', 'False'))
settings['perf_profiler'] = perf_profiler
config = Configurator(settings=settings)
config.add_directive('add_restful_routes', routing.add_restful_routes)
set_globals(**settings)
from . import config as global_config
secret = str(uuid.uuid4())
# NOTE: Beaker include! By John Doe
config.include('pyramid_beaker')
# TODO: Talvez faça-se necessário "descomentar" o que vai abaixo!
# By Questor
# if global_config.AUTH_ENABLED is True:
# authn_policy=AuthTktAuthenticationPolicy(
# secret,
# callback=verify_api_key,
# hashalg='sha512',
# include_ip=global_config.AUTH_INCLUDE_IP
# )
# authz_policy=ACLAuthorizationPolicy()
# config.set_authentication_policy(authn_policy)
# config.set_authorization_policy(authz_policy)
model.make_restful_app()
routing.make_routes(config)
config.scan()
app = config.make_wsgi_app()
# NOTE: Add memory profiler middleware! By John Doe
if mem_profiler:
from .mem_profiler import ProfilerMiddleware
app = ProfilerMiddleware(app)
if perf_profiler:
from repoze.profile import ProfileMiddleware
app = ProfileMiddleware(
app,
log_filename='/var/log/lbg_perf_profile.log',
cachegrind_filename='./cachegrind.out.bar',
discard_first_request=True,
flush_at_shutdown=True,
path='/__perf_profiler',
unwind=False
)
return app
def includeme(config: Configurator):
config.include('restfw')
settings = config.get_settings()
prefix = settings.get('restfw_admin.prefix', 'admin').strip('/')
settings['restfw_admin.prefix'] = prefix
from .resources import Admin
def add_to_root(event):
root = event.root
root[prefix] = Admin()
from restfw.interfaces import IRootCreated
config.add_subscriber(add_to_root, IRootCreated)
from .views import admin_ui, redirect_to_admin_ui
ui_url = f'/{prefix}/ui'
config.add_route('admin_ui_ts', f'{ui_url}/')
config.add_view(admin_ui, route_name='admin_ui_ts', request_method='GET')
config.add_route('admin_ui', ui_url)
config.add_view(redirect_to_admin_ui,
route_name='admin_ui',
request_method='GET')
config.add_route('admin_ui_index', f'{ui_url}/index.html')
config.add_view(redirect_to_admin_ui,
route_name='admin_ui_index',
request_method='GET')
import os
from pathlib import Path
admin_ui_dir = Path(__file__).parent / 'admin_ui'
config.add_static_view(name=ui_url, path=os.fspath(admin_ui_dir))
import re
from .config import get_admin_ui_settings
index_html = (admin_ui_dir / 'index.html').read_text('utf-8')
index_html_tpl = re.sub(
r'<script>window\.__RESTFW_ADMIN_PARAMS__.+?</script>',
'__ADMIN_PARAMS__',
index_html,
)
ui_settings = get_admin_ui_settings(config.registry)
ui_settings.index_html_tpl = index_html_tpl
from .config import add_resource_admin
config.add_directive('add_resource_admin', add_resource_admin)
from .fields import add_field_converter
config.add_directive('add_field_converter', add_field_converter)
from restfw.utils import scan_ignore
config.scan(ignore=scan_ignore(config.registry))
def includeme(config: Configurator):
from .external_links import add_external_link_fabric, add_external_link_fabric_predicate
from .sub_resources import add_sub_resource_fabric, add_sub_resource_fabric_predicate
from .views import add_resource_view
config.add_directive('add_sub_resource_fabric', add_sub_resource_fabric)
config.add_directive('add_sub_resource_fabric_predicate', add_sub_resource_fabric_predicate)
config.add_directive('add_external_link_fabric', add_external_link_fabric)
config.add_directive('add_external_link_fabric_predicate', add_external_link_fabric_predicate)
config.add_directive('add_resource_view', add_resource_view)
def includeme(config: Configurator):
# The ChangeHandler is a configurable callback run when there is a
# new Changeset. There should only be one. A default is provided
# but it can be overridden with the directive.
ch = ChangeHandler(config)
config.registry.change_handler = ch
config.add_directive('register_changehandler', register_changehandler)
# The Threadrunner watches changes on disk and calls the callback.
# Subscribe to ApplicationCreated to start the
# threadrunner as late as possible
config.add_subscriber(start_threadrunner, ApplicationCreated)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
mem_profiler = asbool(settings.get('mem_profiler', 'False'))
settings['mem_profiler'] = mem_profiler
perf_profiler = asbool(settings.get('perf_profiler', 'False'))
settings['perf_profiler'] = perf_profiler
config = Configurator(settings=settings)
config.add_directive('add_restful_routes', routing.add_restful_routes)
set_globals(**settings)
from . import config as global_config
secret = str(uuid.uuid4())
# NOTE: Beaker include! By John Doe
config.include('pyramid_beaker')
# TODO: Talvez faça-se necessário "descomentar" o que vai abaixo!
# By Questor
# if global_config.AUTH_ENABLED is True:
# authn_policy=AuthTktAuthenticationPolicy(
# secret,
# callback=verify_api_key,
# hashalg='sha512',
# include_ip=global_config.AUTH_INCLUDE_IP
# )
# authz_policy=ACLAuthorizationPolicy()
# config.set_authentication_policy(authn_policy)
# config.set_authorization_policy(authz_policy)
model.make_restful_app()
routing.make_routes(config)
config.scan()
app = config.make_wsgi_app()
# NOTE: Add memory profiler middleware! By John Doe
if mem_profiler:
from .mem_profiler import ProfilerMiddleware
app = ProfilerMiddleware(app)
if perf_profiler:
from repoze.profile import ProfileMiddleware
app = ProfileMiddleware(app,
log_filename='/var/log/lbg_perf_profile.log',
cachegrind_filename='./cachegrind.out.bar',
discard_first_request=True,
flush_at_shutdown=True,
path='/__perf_profiler',
unwind=False)
return app
def includeme(config: Configurator):
rest_config = config.registry.restalchemy
# Pyramid requires an authorization policy to be active.
config.set_authorization_policy(ACLAuthorizationPolicy())
# Enable JWT authentication.
config.include("pyramid_jwt")
config.set_jwt_authentication_policy(auth_type="Bearer")
config.add_route("restalchemy.login",
"/" + rest_config.api_version + "/login")
config.add_directive("set_authenticate_function",
set_authenticate_function,
action_wrap=True)
def test_start_scheduler_without_cache_in_configuration(mock):
from papaye.config.startup import start_scheduler
from papaye.tasks.devices import DummyScheduler
from papaye.config.utils import SettingsReader
config = Configurator()
config.registry.settings = {
'papaye.cache': 'true',
}
config.add_directive('settings_reader', lambda c: SettingsReader(c))
start_scheduler(config)
get_current_request()
assert isinstance(mock.call_args[0][0], DummyScheduler)
def test_start_scheduler(mock):
from papaye.config.startup import start_scheduler
from papaye.config.utils import SettingsReader
config = Configurator()
config.registry.settings = {
'papaye.cache': 'true',
'papaye.scheduler': 'papaye.tests.test_config:SchedulerTest',
}
config.add_directive('settings_reader', lambda c: SettingsReader(c))
start_scheduler(config)
get_current_request()
assert isinstance(mock.call_args[0][0], SchedulerTest)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
config = Configurator(settings=settings)
config.include('pyramid_handlers')
config.include('pyramid_jinja2')
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.add_directive('add_magic_handler', add_magic_handler)
config.add_subscriber(add_renderer_globals, BeforeRender)
config.add_static_view('statics', 'blog:statics')
# Home route
config.add_handler('home', get_route(), get_handler('blog'), 'index')
# Index/Action routes
config.add_magic_handler('user')
config.add_magic_handler('post')
config.add_magic_handler('tag')
config.add_magic_handler('snippet')
config.add_magic_handler('media')
config.add_magic_handler('feed')
# Compatibilidade
config.add_handler('feed_comp', get_route('feed'), get_handler('feed'),
'feed')
# Custom routes
config.add_handler('blog_index', get_route('blogs'), get_handler('blog'),
'index')
config.add_handler('blog_entry', get_route('blogs', '{id}', '{alias}'),
get_handler('blog'), 'view')
config.add_handler('snippet_index', get_route('snippet'),
get_handler('blog'), 'snippet_index')
config.add_handler('snippet_entry', get_route('snippet', '{id}',
'{alias}'),
get_handler('blog'), 'snippet_view')
config.add_handler('article', get_route('articles'), get_handler('blog'),
'article')
config.add_handler('page', get_route('{alias}'), get_handler('blog'),
'page')
return config.make_wsgi_app()
def includeme(config: Configurator):
registry = config.registry # type: Registry
cli = Cli(registry=registry)
# Add `add_command` directive
config.add_directive('add_command', add_command)
# Register CLI component
registry.registerUtility(cli, ICli)
commands = registry.settings.get('cli.commands', [])
# Register commands from settings
for command in commands:
config.add_command(command)
def includeme(config: Configurator):
def action():
logger.info("Executing config action [exception views].")
config.app_exception_view(Exception, ExceptionView,
"templates/exception/exception.jinja2")
config.app_exception_view(OperationArgumentException,
OperationArgumentExceptionView,
"templates/exception/exception.jinja2")
config.app_exception_view(HTTPNotFound, ExceptionView,
"templates/exception/exception.jinja2")
intr = config.introspectable('app modules', __name__,
"App module %r" % __name__, 'app modules')
config.add_directive("app_exception_view", app_exception_view)
disc = ('exception views', )
config.action(None, action, introspectables=(intr, ))
def includeme(config: Configurator):
registry = config.registry # type: Registry
cli = Cli(registry=registry)
# Add `add_command` directive
config.add_directive('add_command', add_command)
# Register CLI component
registry.registerUtility(cli, ICli)
commands = registry.settings.get('cli.commands', [])
# Register commands from settings
for command in commands:
config.add_command(command)
def includeme(config: Configurator) -> None:
"""Pyramid knob."""
config.add_view_deriver(openapi_view)
config.add_directive("pyramid_openapi3_add_formatter", add_formatter)
config.add_directive("pyramid_openapi3_add_explorer", add_explorer_view)
config.add_directive("pyramid_openapi3_spec", add_spec_view)
config.add_directive(
"pyramid_openapi3_validation_error_view", add_validation_error_view
)
def includeme(config: Configurator):
ep_factory = EntryPointFactory()
config.registry.registerUtility(ep_factory, IEntryPointFactory)
config.add_directive('get_root_resource', _get_root_resource)
# config.add_directive('get_resource_root', _get_root_resource)
config.add_directive('get_resource_context', _get_resource_context)
config.add_directive('set_resource_context', _set_resource_context)
config.include('.myapp_config')
# this "looks" redundant, but we have "views" and "view" - fun. FIXME
config.include('.view')
config.registry.registerUtility(NamespaceStore('form_name'),
INamespaceStore, 'form_name')
config.registry.registerUtility(NamespaceStore('namespace'),
INamespaceStore, 'namespace')
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# respect Heroku Environment VAR
resolve_env_value(settings, 'sqlalchemy.url')
resolve_env_value(settings, 'frontend.domain')
resolve_env_value(settings, 'mandrill.sender', '')
resolve_env_value(settings, 'admin.emails')
engine = engine_from_config(settings, 'sqlalchemy.')
log.info("DB Connected at: %s" % settings['sqlalchemy.url'])
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings,
authentication_policy=AuthProvider(settings),
authorization_policy=ACLAuthorizationPolicy(),
session_factory=session_factory_from_settings(settings),
root_factory=RootResource,
default_permission='default_permission')
def get_front_end_domain(request):
return settings['frontend.domain']
config.add_request_method(get_front_end_domain, 'frontend_domain', reify=True)
config.add_directive('add_mako_renderer', pyramid_mako.add_mako_renderer)
config.add_mako_renderer(".html")
config.add_renderer('json', jsonRenderer)
config.add_renderer(None, jsonRenderer)
config.add_view_predicate('content_type', ContentTypePredicate)
config.add_request_method(log_activity, 'log_activity', reify=True)
config.add_request_method(emailer_factory(settings), 'emailer', reify=True)
config.add_request_method(get_candidate_id, 'candidate_id', property=True)
config.add_request_method(get_employer_id, 'employer_id', property=True)
config.add_static_view('static', 'static', cache_max_age=3600)
config.include('scotty.views')
config.scan()
app = config.make_wsgi_app()
return CORS(app)
def main(global_config, **settings):
"""This function returns a Pyramid WSGI application."""
config = Configurator(settings=settings)
config.include("pyramid_chameleon")
config.add_directive("add_cors_preflight_handler",
add_cors_preflight_handler)
config.add_route_predicate("cors_preflight", CorsPreflightPredicate)
config.add_subscriber(add_cors_to_response, "pyramid.events.NewResponse")
config.add_route(
"cors-options-preflight",
"/{catch_all:.*}",
cors_preflight=True,
)
config.add_view(
cors_options_view,
route_name="cors-options-preflight",
permission=NO_PERMISSION_REQUIRED,
)
config.add_renderer("prettyjson", JSON(indent=4, sort_keys=True))
config.add_static_view("static", "static", cache_max_age=3600)
config.add_route("home", "/")
config.add_route("programs", "/playlist")
config.add_route("program-type-list", "/program-type-list")
config.add_route("program-type-news", "/program-type-news")
config.add_route("playlist", "/playlist/{playlist_id}")
config.add_route("playlist-per-type", "/type-playlist/{playlist_id}")
config.add_route("radio", "/radio")
config.add_route("radio-program-type-list", "/radio-program-type-list")
config.add_route("radio-playlist-per-type",
"/type-rplaylist/{playlist_id}")
config.add_route("radio-stations", "/radio-stations")
config.add_route("radio-station-program-list",
"/radio-station-programs/{station_id}")
config.add_route("radioplaylist",
"/rplaylist/{playlist_id:[a-zA-Z0-9\.\-\/]+}")
config.add_route("episode", "/episode/{episode_url:[a-zA-Z0-9\.\-\/]+}")
config.add_route('last-broadcast-list', '/last-broadcast-list')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
"""
This function returns a Pyramid WSGI application.
"""
# TODO learn logging package
# TODO drink double coffee
config = Configurator(settings=settings)
config.include('pyramid_jinja2')
config.include('iap.common.repository.db')
config.include(common_routing)
config.include(forecast_routing, route_prefix='/forecast')
# Add routing for another tools
config.add_directive('create_error_manager', create_error_manager)
config.create_error_manager()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
urihand_settings = _parse_settings(config.registry.settings)
handlerconfig = _load_configuration(urihand_settings['config'])
_build_uri_handler(config.registry, handlerconfig)
config.add_directive('get_uri_handler', get_uri_handler)
config.add_request_method(get_uri_handler, 'uri_handler', reify=True)
config.add_route('handle', '/handle')
config.add_route('uris', '/uris')
config.add_route('redirect', '/{uri:.*}')
config.scan()
return config.make_wsgi_app()
def make_toolbar_app(settings, parent_registry):
""" WSGI application for rendering the debug toolbar."""
config = Configurator(settings=settings)
config.registry.parent_registry = parent_registry
config.registry.registerUtility(OrderedDict(), IPanelMap)
config.add_directive('add_debugtoolbar_panel', add_debugtoolbar_panel)
config.add_directive('inject_parent_action', inject_parent_action)
config.include('pyramid_mako')
config.add_mako_renderer('.dbtmako', settings_prefix='dbtmako.')
config.add_request_method(
lambda r: r.matchdict.get('request_id'),
'pdtb_id',
reify=True,
)
config.add_request_method(
lambda r: r.registry.parent_registry.pdtb_history,
'pdtb_history',
reify=True,
)
config.add_static_view('static', STATIC_PATH)
config.add_route(ROOT_ROUTE_NAME, '/', static=True)
config.add_route('debugtoolbar.sse', '/sse')
config.add_route('debugtoolbar.redirect', '/redirect')
config.add_route('debugtoolbar.request', '/{request_id}')
config.add_route('debugtoolbar.main', '/')
config.scan(__name__)
for include in bundled_includes:
config.include(include)
# commit the toolbar config and include any user-defined includes
config.commit()
includes = settings.get(SETTINGS_PREFIX + 'includes', ())
for include in includes:
config.include(include)
return config.make_wsgi_app()
def includeme(config: Configurator) -> None:
"""
Include the simple SQLAlchemy configuration with reasonable defaults.
:param config: the configurator
"""
try:
import sqlalchemy
except ImportError as e:
raise RuntimeError('sqlalchemy cannot be imported, '
'unable to include tet.sqlalchemy.simple') from e
config.include('pyramid_services')
settings = config.get_settings()
settings['tm.manager_hook'] = 'pyramid_tm.explicit_manager'
# use pyramid_tm to hook the transaction lifecycle to the request
config.include('pyramid_tm')
config.add_directive('setup_sqlalchemy', setup_sqlalchemy)
def includeme(config: Configurator) -> None:
"""
Include the simple SQLAlchemy configuration with reasonable defaults.
:param config: the configurator
"""
try:
import sqlalchemy
except ImportError as e:
raise RuntimeError('sqlalchemy cannot be imported, '
'unable to include tet.sqlalchemy.simple') from e
config.include('pyramid_services')
settings = config.get_settings()
settings['tm.manager_hook'] = 'pyramid_tm.explicit_manager'
# use pyramid_tm to hook the transaction lifecycle to the request
config.include('pyramid_tm')
config.add_directive('setup_sqlalchemy', setup_sqlalchemy)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
settings["g"] = g = Globals(**settings)
config = Configurator(settings=settings
, session_factory=session_factory_from_settings(settings)
, authentication_policy=Security()
, authorization_policy=ACLAuthorizationPolicy()
, default_permission='view'
)
request.extend_request_dispatch(config)
config.add_directive('add_mako_renderer', pyramid_mako.add_mako_renderer)
config.add_mako_renderer(".html")
config.add_mako_renderer(".xml")
config.add_renderer('json', jsonRenderer)
def _(request, string):
return string
config.add_request_method(_)
def pluralize(request, singular, plural, num):
return singular.format(num=num) if num == 1 else plural.format(num=num)
config.add_request_method(pluralize)
config.add_subscriber(add_renderer_variables, 'pyramid.events.BeforeRender')
def dictionary_factory(request):
result = GetStaticContentProc(request)
return {k.key:k.value for k in result.Static}
POFILE = set_up_content_mgmt_app(config, "klinik:locale/klinik.pot", dictionary_factory)
g.set_po_file(POFILE)
config.include("klinik.views.website")
config.include("klinik.views.admin", route_prefix="/admin")
config.add_route("admin_home", "/admin", factory=AdminResource) # this is required to admin tool is at /admin and not /admin/
return config.make_wsgi_app()
def includeme(config: Configurator) -> None:
"""Pyramid knob."""
config.add_view_deriver(openapi_view)
config.add_directive("pyramid_openapi3_add_formatter", add_formatter)
config.add_directive("pyramid_openapi3_add_explorer", add_explorer_view)
config.add_directive("pyramid_openapi3_spec", add_spec_view)
config.add_tween("pyramid_openapi3.tween.response_tween_factory",
over=EXCVIEW)
def main(global_config, **settings):
"""This function returns a Pyramid WSGI application."""
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_directive(
'add_cors_preflight_handler', add_cors_preflight_handler)
config.add_route_predicate('cors_preflight', CorsPreflightPredicate)
config.add_subscriber(add_cors_to_response, 'pyramid.events.NewResponse')
config.add_route(
'cors-options-preflight', '/{catch_all:.*}',
cors_preflight=True,
)
config.add_view(
cors_options_view,
route_name='cors-options-preflight',
permission=NO_PERMISSION_REQUIRED,
)
config.add_renderer('prettyjson', JSON(indent=4, sort_keys=True))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('programs', '/playlist')
config.add_route('program-type-list', '/program-type-list')
config.add_route('program-type-news', '/program-type-news')
config.add_route('playlist', '/playlist/{playlist_id}')
config.add_route('playlist-per-type', '/type-playlist/{playlist_id}')
config.add_route('radio', '/radio')
config.add_route('radio-program-type-list', '/radio-program-type-list')
config.add_route('radio-playlist-per-type', '/type-rplaylist/{playlist_id}')
config.add_route('radio-stations', '/radio-stations')
config.add_route('radio-station-program-list', '/radio-station-programs/{station_id}')
config.add_route('radioplaylist', '/rplaylist/{playlist_id:[a-zA-Z0-9\.\-\/]+}')
config.add_route('episode', '/episode/{episode_url:[a-zA-Z0-9\.\-\/]+}')
config.scan()
return config.make_wsgi_app()
def includeme(config: Configurator):
config.include('restfw.config')
from . import predicates
from .viewderivers import register_view_derivers
config.set_root_factory('restfw.root.root_factory')
config.add_renderer(None, 'restfw.renderers.json_renderer')
predicates = [
('debug', predicates.DebugPredicate),
('testing', predicates.TestingPredicate),
('debug_or_testing', predicates.DebugOrTestingPredicate),
]
for name, fabric in predicates:
config.add_view_predicate(name, fabric)
config.add_subscriber_predicate(name, fabric)
from .usage_examples.config import add_usage_examples_fabric_predicate
from .usage_examples.config import add_usage_examples_fabric
config.add_directive('add_usage_examples_fabric',
add_usage_examples_fabric)
config.add_directive('add_usage_examples_fabric_predicate',
add_usage_examples_fabric_predicate)
register_view_derivers(config)
# Fix memory leaks on pyramid segment cache
import pyramid.traversal
if pyramid.traversal._segment_cache.__class__ is dict:
from lru import LRU
pyramid.traversal._segment_cache = LRU(1000)
from .utils import scan_ignore
ignore = scan_ignore(config.registry)
ignore.extend([
'.docs_gen',
])
config.scan(ignore=ignore)
def includeme(config: Configurator) -> None:
"""Pyramid knob."""
config.add_view_deriver(openapi_view)
config.add_directive("pyramid_openapi3_add_formatter", add_formatter)
config.add_directive("pyramid_openapi3_add_explorer", add_explorer_view)
config.add_directive("pyramid_openapi3_spec", add_spec_view)
config.add_directive("pyramid_openapi3_spec_directory", add_spec_view_directory)
config.add_directive("pyramid_openapi3_register_routes", register_routes)
config.add_tween("pyramid_openapi3.tween.response_tween_factory", over=EXCVIEW)
config.add_subscriber(check_all_routes, ApplicationCreated)
if not config.registry.settings.get( # pragma: no branch
"pyramid_openapi3_extract_errors"
):
config.registry.settings["pyramid_openapi3_extract_errors"] = extract_errors
config.add_exception_view(
view=openapi_validation_error, context=RequestValidationError, renderer="json"
)
config.add_exception_view(
view=openapi_validation_error, context=ResponseValidationError, renderer="json"
)
def main(global_config, **settings):
config = Configurator(
autocommit=True,
settings=settings,
authentication_policy=AuthenticationPolicy(settings['auth.file'], __name__),
authorization_policy=AuthorizationPolicy(),
route_prefix=route_prefix(settings),
)
config.include('pyramid_exclog')
config.include("cornice")
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_request_method(extract_tender, 'tender', reify=True)
config.add_request_method(check_accreditation)
config.add_request_method(json_body, 'json_body', reify=True)
config.add_renderer('json', JSON(serializer=simplejson.dumps))
config.add_renderer('prettyjson', JSON(indent=4, serializer=simplejson.dumps))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp', serializer=simplejson.dumps))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp', serializer=simplejson.dumps))
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.api.views.spore")
config.scan("openprocurement.api.views.health")
# tender procurementMethodType plugins support
config.add_route_predicate('procurementMethodType', isTender)
config.registry.tender_procurementMethodTypes = {}
config.add_request_method(tender_from_data)
config.add_directive('add_tender_procurementMethodType', register_tender_procurementMethodType)
# search for plugins
plugins = settings.get('plugins') and settings['plugins'].split(',')
for entry_point in iter_entry_points('openprocurement.api.plugins'):
if not plugins or entry_point.name in plugins:
plugin = entry_point.load()
plugin(config)
# CouchDB connection
db_name = os.environ.get('DB_NAME', settings['couchdb.db_name'])
server = Server(settings.get('couchdb.url'), session=Session(retry_delays=range(10)))
if 'couchdb.admin_url' not in settings and server.resource.credentials:
try:
server.version()
except Unauthorized:
server = Server(extract_credentials(settings.get('couchdb.url'))[0])
config.registry.couchdb_server = server
if 'couchdb.admin_url' in settings and server.resource.credentials:
aserver = Server(settings.get('couchdb.admin_url'), session=Session(retry_delays=range(10)))
config.registry.admin_couchdb_server = aserver
users_db = aserver['_users']
if SECURITY != users_db.security:
LOGGER.info("Updating users db security", extra={'MESSAGE_ID': 'update_users_security'})
users_db.security = SECURITY
username, password = server.resource.credentials
user_doc = users_db.get('org.couchdb.user:{}'.format(username), {'_id': 'org.couchdb.user:{}'.format(username)})
if not user_doc.get('derived_key', '') or PBKDF2(password, user_doc.get('salt', ''), user_doc.get('iterations', 10)).hexread(int(len(user_doc.get('derived_key', '')) / 2)) != user_doc.get('derived_key', ''):
user_doc.update({
"name": username,
"roles": [],
"type": "user",
"password": password
})
LOGGER.info("Updating api db main user", extra={'MESSAGE_ID': 'update_api_main_user'})
users_db.save(user_doc)
security_users = [username, ]
if 'couchdb.reader_username' in settings and 'couchdb.reader_password' in settings:
reader_username = settings.get('couchdb.reader_username')
reader = users_db.get('org.couchdb.user:{}'.format(reader_username), {'_id': 'org.couchdb.user:{}'.format(reader_username)})
if not reader.get('derived_key', '') or PBKDF2(settings.get('couchdb.reader_password'), reader.get('salt', ''), reader.get('iterations', 10)).hexread(int(len(reader.get('derived_key', '')) / 2)) != reader.get('derived_key', ''):
reader.update({
"name": reader_username,
"roles": ['reader'],
"type": "user",
"password": settings.get('couchdb.reader_password')
})
LOGGER.info("Updating api db reader user", extra={'MESSAGE_ID': 'update_api_reader_user'})
users_db.save(reader)
security_users.append(reader_username)
if db_name not in aserver:
aserver.create(db_name)
db = aserver[db_name]
SECURITY[u'members'][u'names'] = security_users
if SECURITY != db.security:
LOGGER.info("Updating api db security", extra={'MESSAGE_ID': 'update_api_security'})
db.security = SECURITY
auth_doc = db.get(VALIDATE_DOC_ID, {'_id': VALIDATE_DOC_ID})
if auth_doc.get('validate_doc_update') != VALIDATE_DOC_UPDATE % username:
auth_doc['validate_doc_update'] = VALIDATE_DOC_UPDATE % username
LOGGER.info("Updating api db validate doc", extra={'MESSAGE_ID': 'update_api_validate_doc'})
db.save(auth_doc)
# sync couchdb views
sync_design(db)
db = server[db_name]
else:
if db_name not in server:
server.create(db_name)
db = server[db_name]
# sync couchdb views
sync_design(db)
config.registry.db = db
# readjust couchdb json decoder
couchdb_json_decode()
# Document Service key
config.registry.docservice_url = settings.get('docservice_url')
config.registry.docservice_username = settings.get('docservice_username')
config.registry.docservice_password = settings.get('docservice_password')
config.registry.docservice_upload_url = settings.get('docservice_upload_url')
config.registry.docservice_key = dockey = Signer(settings.get('dockey', '').decode('hex'))
config.registry.keyring = keyring = {}
dockeys = settings.get('dockeys') if 'dockeys' in settings else dockey.hex_vk()
for key in dockeys.split('\0'):
keyring[key[:8]] = Verifier(key)
# migrate data
if not os.environ.get('MIGRATION_SKIP'):
for entry_point in iter_entry_points('openprocurement.api.migrations'):
plugin = entry_point.load()
plugin(config.registry)
config.registry.server_id = settings.get('id', '')
config.registry.health_threshold = float(settings.get('health_threshold', 99))
config.registry.update_after = asbool(settings.get('update_after', True))
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(
autocommit=True,
settings=settings,
authentication_policy=AuthenticationPolicy(settings['auth.file'],
__name__),
authorization_policy=AuthorizationPolicy(),
route_prefix=ROUTE_PREFIX,
)
config.include('pyramid_exclog')
config.include("cornice")
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_request_method(extract_tender, 'tender', 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.api.views.spore")
# tender procurementMethodType plugins support
config.add_route_predicate('procurementMethodType', isTender)
config.registry.tender_procurementMethodTypes = {}
config.add_request_method(tender_from_data)
config.add_directive('add_tender_procurementMethodType',
register_tender_procurementMethodType)
# search for plugins
plugins = settings.get('plugins') and settings['plugins'].split(',')
for entry_point in iter_entry_points('openprocurement.api.plugins'):
if not plugins or entry_point.name in plugins:
plugin = entry_point.load()
plugin(config)
# CouchDB connection
db_name = os.environ.get('DB_NAME', settings['couchdb.db_name'])
server = Server(settings.get('couchdb.url'),
session=Session(retry_delays=range(10)))
if 'couchdb.admin_url' not in settings and server.resource.credentials:
try:
server.version()
except Unauthorized:
server = Server(
extract_credentials(settings.get('couchdb.url'))[0])
config.registry.couchdb_server = server
if 'couchdb.admin_url' in settings and server.resource.credentials:
aserver = Server(settings.get('couchdb.admin_url'),
session=Session(retry_delays=range(10)))
users_db = aserver['_users']
if SECURITY != users_db.security:
LOGGER.info("Updating users db security",
extra={'MESSAGE_ID': 'update_users_security'})
users_db.security = SECURITY
username, password = server.resource.credentials
user_doc = users_db.get(
'org.couchdb.user:{}'.format(username),
{'_id': 'org.couchdb.user:{}'.format(username)})
if not user_doc.get(
'derived_key', '') or PBKDF2(password, user_doc.get(
'salt', ''), user_doc.get('iterations', 10)).hexread(
int(len(user_doc.get('derived_key', '')) /
2)) != user_doc.get('derived_key', ''):
user_doc.update({
"name": username,
"roles": [],
"type": "user",
"password": password
})
LOGGER.info("Updating api db main user",
extra={'MESSAGE_ID': 'update_api_main_user'})
users_db.save(user_doc)
security_users = [
username,
]
if 'couchdb.reader_username' in settings and 'couchdb.reader_password' in settings:
reader_username = settings.get('couchdb.reader_username')
reader = users_db.get(
'org.couchdb.user:{}'.format(reader_username),
{'_id': 'org.couchdb.user:{}'.format(reader_username)})
if not reader.get('derived_key', '') or PBKDF2(
settings.get('couchdb.reader_password'),
reader.get('salt', ''), reader.get(
'iterations', 10)).hexread(
int(len(reader.get('derived_key', '')) /
2)) != reader.get('derived_key', ''):
reader.update({
"name":
reader_username,
"roles": ['reader'],
"type":
"user",
"password":
settings.get('couchdb.reader_password')
})
LOGGER.info("Updating api db reader user",
extra={'MESSAGE_ID': 'update_api_reader_user'})
users_db.save(reader)
security_users.append(reader_username)
if db_name not in aserver:
aserver.create(db_name)
db = aserver[db_name]
SECURITY[u'members'][u'names'] = security_users
if SECURITY != db.security:
LOGGER.info("Updating api db security",
extra={'MESSAGE_ID': 'update_api_security'})
db.security = SECURITY
auth_doc = db.get(VALIDATE_DOC_ID, {'_id': VALIDATE_DOC_ID})
if auth_doc.get(
'validate_doc_update') != VALIDATE_DOC_UPDATE % username:
auth_doc['validate_doc_update'] = VALIDATE_DOC_UPDATE % username
LOGGER.info("Updating api db validate doc",
extra={'MESSAGE_ID': 'update_api_validate_doc'})
db.save(auth_doc)
# sync couchdb views
sync_design(db)
db = server[db_name]
else:
if db_name not in server:
server.create(db_name)
db = server[db_name]
# sync couchdb views
sync_design(db)
config.registry.db = db
# migrate data
migrate_data(config.registry.db)
# S3 connection
if 'aws.access_key' in settings and 'aws.secret_key' in settings and 'aws.s3_bucket' in settings:
connection = S3Connection(settings['aws.access_key'],
settings['aws.secret_key'])
config.registry.s3_connection = connection
bucket_name = settings['aws.s3_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
config.registry.server_id = settings.get('id', '')
return config.make_wsgi_app()
def main(argv=sys.argv):
if len(argv) != 3:
usage(argv)
config_uri = argv[1]
try:
num_users = int(argv[2])
except ValueError:
usage(argv)
setup_logging(config_uri)
settings = get_appsettings(config_uri)
config = Configurator(settings=settings)
config.add_directive('set_password_context', set_password_context)
db_session = init_sa(config)
logger = logging.getLogger('speak_friend.createusers')
if 'speak_friend.password_hasher' in settings:
config.include(settings['speak_friend.password_hasher'])
else:
from passlib.apps import ldap_context
config.set_password_context(context=ldap_context)
# makes the password_context available on the registry
config.commit()
pass_ctx = config.registry.password_context
user_num = 1
buf = StringIO()
cols = [
'username', 'first_name', 'last_name', 'email', 'password_hash',
'password_salt', 'login_attempts', 'admin_disabled', 'is_superuser'
]
csv_file = csv.DictWriter(buf, cols, delimiter='\t', lineterminator='\n')
logger.info("Beginning to create %d users,", num_users)
cxn = db_session.connection()
cur = cxn.connection.cursor()
user_num += 0
user_passwords = {}
while user_num <= num_users:
first_name = u'Test'
last_name = pwgen(num_pw=1,
pw_length=10,
no_numerals=True,
no_symbols=True)
username = u'%s.%s' % (first_name, last_name)
password = pwgen(num_pw=1, pw_length=20)
user_passwords[username] = password
csv_file.writerow(
dict(
username=username,
first_name=first_name,
last_name=last_name,
email=u'*****@*****.**' % username,
password_hash=pass_ctx.encrypt(password),
password_salt='',
login_attempts=0,
admin_disabled=False,
is_superuser=False,
))
logger.info("Created user %s, %04d/%04d.", username, user_num,
num_users)
user_num += 1
logger.info("Committing...")
tname = '%s.%s' % (UserProfile.__table__.schema,
UserProfile.__table__.name)
buf.seek(0)
cur.copy_from(buf, tname, columns=cols)
cxn.connection.commit()
for uname, pw in user_passwords.items():
print uname, pw
def main(global_settings, **settings):
# TODO should allow end user to configure logging, of course; this is just
# a nice default
coloredlogs.install(level=logging.INFO)
# TODO this doesn't actually work as a paste entry point, because the ini
# values need converting :S
datadir = Path(settings['spline.datadir'])
# Built-in core settings we have to have. These are part of the app
# propert and it makes zero sense for either a deployer or a developer to
# ever change them.
# TODO is this where this kind of thing should go? seems, y'know, clunky
settings.update({
'pyramid.default_locale_name': u'en',
'mako.directories': ['spline:templates'],
'mako.module_directory': str(datadir / '_mako_cache'),
'mako.strict_undefined': True,
# TODO i am not thrilled that only a string works here
# TODO: pyramid_scss should learn to do asset specs in imports as well,
# but scss needs import hooking for that to work
'scss.asset_path': 'spline:assets/scss\n'
'spline:assets/vendor/archetype/scss',
# These are reversed in debug mode
# TODO scss should really be built and served directly in production
'scss.compress': True,
'scss.cache': True,
})
# Prefill some paths for stuff stored on disk.
# TODO this is pretty grody :)
# TODO this should be a little more organized and enforce that the
# directories exist and are writable by us -- or at least that the datadir
# itself is?
settings.update({
'spline.search.whoosh.path': str(datadir / 'whoosh-index'),
'spline.wiki.root': str(datadir / 'wiki'),
# TODO this is all going away, i think. lol CHANGEME. what is that
# even for?
'session.type': 'file',
'session.data_dir': str(datadir / 'sessions/data'),
'session.lock_dir': str(datadir / 'sessions/lock'),
'session.secret': 'CHANGEME',
'session.cookie_on_exception': True,
})
debug = settings.get('spline.debug')
if debug:
settings.update({
# TODO maybe i want to turn these on... why didn't i?
'pyramid.debug_authorization': True,
'pyramid.debug_notfound': True,
'pyramid.debug_routematch': True,
'pyramid.reload_templates': True,
'scss.compress': False,
'scss.cache': False,
})
engine = engine_from_config(settings, 'sqlalchemy.')
session.configure(bind=engine)
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config = Configurator(settings=settings)
if debug:
# TODO only if importable?
config.include('pyramid_debugtoolbar')
config.include('pyramid_tm')
config.include('pyramid_mako')
from spline.feature.filestore import IStorage, FilesystemStorage
filestore_dir = (datadir / 'filestore').resolve()
config.registry.registerUtility(FilesystemStorage(filestore_dir), IStorage)
config.add_static_view('filestore', str(filestore_dir))
# Sessions
config.include(pyramid_beaker)
config.set_session_factory(session_factory)
config.add_tween('spline.web.auth.csrf_tween_factory')
# Auth
config.set_authentication_policy(DatabaseAuthenticationPolicy())
config.set_authorization_policy(RoleAuthorizationPolicy())
config.add_request_method(authenticated_userid, 'user', reify=True)
# Events
config.add_subscriber(inject_template_vars, BeforeRender)
# Static assets
config.add_static_view('static', 'spline:assets', cache_max_age=3600)
# Load core stuff first
config.include(core_plugin_includeme)
# Plugin loading
# TODO this could totally be inside the app proper, as long as i know how
# to restart myself. mamayo problem?
# TODO there are really two steps here, of scanning and then importing.
# but i doubt the web app itself wants to scan just to import, right?
# TODO now there's both a plugin dict here AND a "registry" in the Plugin
# class itself (which is still in spline_comic btw) -- which is correct?
# TODO SIGH should i just give up and use setuptools f*****g entry points
# TODO or actually maybe i should be taking advantage of zope things here
# -- you can have named implementations of an interface after all!
config.registry.spline_plugins = {}
config.add_directive('register_spline_plugin',
config_register_spline_plugin)
for plugins in settings.get('spline.plugins', ()):
plugin, route_prefix = plugins.split(':', 1)
config.include(plugin, route_prefix=route_prefix)
# Sass compilation
# TODO this has to appear after the includes, or pyramid_scss won't see any
# additional paths added. needs a real api for doing that
config.include('pyramid_scss')
config.add_route('pyscss', '/css/{css_path:[^/]+}.css')
config.add_view(route_name='pyscss',
view='pyramid_scss.controller.get_scss',
renderer='scss',
request_method='GET')
return config.make_wsgi_app()
def main(global_settings, **settings):
# TODO should allow end user to configure logging, of course; this is just
# a nice default
coloredlogs.install(level=logging.INFO)
# TODO this doesn't actually work as a paste entry point, because the ini
# values need converting :S
datadir = Path(settings['spline.datadir'])
# Built-in core settings we have to have. These are part of the app
# propert and it makes zero sense for either a deployer or a developer to
# ever change them.
# TODO is this where this kind of thing should go? seems, y'know, clunky
settings.update({
'pyramid.default_locale_name': u'en',
'mako.directories': ['spline:templates'],
'mako.module_directory': str(datadir / '_mako_cache'),
'mako.strict_undefined': True,
# TODO i am not thrilled that only a string works here
# TODO: pyramid_scss should learn to do asset specs in imports as well,
# but scss needs import hooking for that to work
'scss.asset_path':
'spline:assets/scss\n'
'spline:assets/vendor/archetype/scss',
# These are reversed in debug mode
# TODO scss should really be built and served directly in production
'scss.compress': True,
'scss.cache': True,
})
# Prefill some paths for stuff stored on disk.
# TODO this is pretty grody :)
# TODO this should be a little more organized and enforce that the
# directories exist and are writable by us -- or at least that the datadir
# itself is?
settings.update({
'spline.search.whoosh.path': str(datadir / 'whoosh-index'),
'spline.wiki.root': str(datadir / 'wiki'),
# TODO this is all going away, i think. lol CHANGEME. what is that
# even for?
'session.type': 'file',
'session.data_dir': str(datadir / 'sessions/data'),
'session.lock_dir': str(datadir / 'sessions/lock'),
'session.secret': 'CHANGEME',
'session.cookie_on_exception': True,
})
debug = settings.get('spline.debug')
if debug:
settings.update({
# TODO maybe i want to turn these on... why didn't i?
'pyramid.debug_authorization': True,
'pyramid.debug_notfound': True,
'pyramid.debug_routematch': True,
'pyramid.reload_templates': True,
'scss.compress': False,
'scss.cache': False,
})
engine = engine_from_config(settings, 'sqlalchemy.')
session.configure(bind=engine)
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config = Configurator(settings=settings)
if debug:
# TODO only if importable?
config.include('pyramid_debugtoolbar')
config.include('pyramid_tm')
config.include('pyramid_mako')
from spline.feature.filestore import IStorage, FilesystemStorage
filestore_dir = (datadir / 'filestore').resolve()
config.registry.registerUtility(FilesystemStorage(filestore_dir), IStorage)
config.add_static_view('filestore', str(filestore_dir))
# Sessions
config.include(pyramid_beaker)
config.set_session_factory(session_factory)
config.add_tween('spline.web.auth.csrf_tween_factory')
# Auth
config.set_authentication_policy(DatabaseAuthenticationPolicy())
config.set_authorization_policy(RoleAuthorizationPolicy())
config.add_request_method(authenticated_userid, 'user', reify=True)
# Events
config.add_subscriber(inject_template_vars, BeforeRender)
# Static assets
config.add_static_view('static', 'spline:assets', cache_max_age=3600)
# Load core stuff first
config.include(core_plugin_includeme)
# Plugin loading
# TODO this could totally be inside the app proper, as long as i know how
# to restart myself. mamayo problem?
# TODO there are really two steps here, of scanning and then importing.
# but i doubt the web app itself wants to scan just to import, right?
# TODO now there's both a plugin dict here AND a "registry" in the Plugin
# class itself (which is still in spline_comic btw) -- which is correct?
# TODO SIGH should i just give up and use setuptools f*****g entry points
# TODO or actually maybe i should be taking advantage of zope things here
# -- you can have named implementations of an interface after all!
config.registry.spline_plugins = {}
config.add_directive(
'register_spline_plugin', config_register_spline_plugin)
for plugins in settings.get('spline.plugins', ()):
plugin, route_prefix = plugins.split(':', 1)
config.include(plugin, route_prefix=route_prefix)
# Sass compilation
# TODO this has to appear after the includes, or pyramid_scss won't see any
# additional paths added. needs a real api for doing that
config.include('pyramid_scss')
config.add_route('pyscss', '/css/{css_path:[^/]+}.css')
config.add_view(route_name='pyscss', view='pyramid_scss.controller.get_scss', renderer='scss', request_method='GET')
return config.make_wsgi_app()
def includeme(config: Configurator):
config.add_directive('add_dotdo_route', struts_one_like)
def main(global_config, **settings):
config = Configurator(
autocommit=True,
settings=settings,
authentication_policy=AuthenticationPolicy(settings['auth.file'], __name__),
authorization_policy=AuthorizationPolicy(),
route_prefix=route_prefix(settings),
)
config.include('pyramid_exclog')
config.include("cornice")
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_request_method(extract_tender, 'tender', reify=True)
config.add_request_method(check_accreditation)
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.api.views.spore")
config.scan("openprocurement.api.views.health")
# tender procurementMethodType plugins support
config.add_route_predicate('procurementMethodType', isTender)
config.registry.tender_procurementMethodTypes = {}
config.add_request_method(tender_from_data)
config.add_directive('add_tender_procurementMethodType', register_tender_procurementMethodType)
# search for plugins
plugins = settings.get('plugins') and settings['plugins'].split(',')
for entry_point in iter_entry_points('openprocurement.api.plugins'):
if not plugins or entry_point.name in plugins:
plugin = entry_point.load()
plugin(config)
# CouchDB connection
db_name = os.environ.get('DB_NAME', settings['couchdb.db_name'])
server = Server(settings.get('couchdb.url'), session=Session(retry_delays=range(10)))
if 'couchdb.admin_url' not in settings and server.resource.credentials:
try:
server.version()
except Unauthorized:
server = Server(extract_credentials(settings.get('couchdb.url'))[0])
config.registry.couchdb_server = server
if 'couchdb.admin_url' in settings and server.resource.credentials:
aserver = Server(settings.get('couchdb.admin_url'), session=Session(retry_delays=range(10)))
config.registry.admin_couchdb_server = aserver
users_db = aserver['_users']
if SECURITY != users_db.security:
LOGGER.info("Updating users db security", extra={'MESSAGE_ID': 'update_users_security'})
users_db.security = SECURITY
username, password = server.resource.credentials
user_doc = users_db.get('org.couchdb.user:{}'.format(username), {'_id': 'org.couchdb.user:{}'.format(username)})
if not user_doc.get('derived_key', '') or PBKDF2(password, user_doc.get('salt', ''), user_doc.get('iterations', 10)).hexread(int(len(user_doc.get('derived_key', '')) / 2)) != user_doc.get('derived_key', ''):
user_doc.update({
"name": username,
"roles": [],
"type": "user",
"password": password
})
LOGGER.info("Updating api db main user", extra={'MESSAGE_ID': 'update_api_main_user'})
users_db.save(user_doc)
security_users = [username, ]
if 'couchdb.reader_username' in settings and 'couchdb.reader_password' in settings:
reader_username = settings.get('couchdb.reader_username')
reader = users_db.get('org.couchdb.user:{}'.format(reader_username), {'_id': 'org.couchdb.user:{}'.format(reader_username)})
if not reader.get('derived_key', '') or PBKDF2(settings.get('couchdb.reader_password'), reader.get('salt', ''), reader.get('iterations', 10)).hexread(int(len(reader.get('derived_key', '')) / 2)) != reader.get('derived_key', ''):
reader.update({
"name": reader_username,
"roles": ['reader'],
"type": "user",
"password": settings.get('couchdb.reader_password')
})
LOGGER.info("Updating api db reader user", extra={'MESSAGE_ID': 'update_api_reader_user'})
users_db.save(reader)
security_users.append(reader_username)
if db_name not in aserver:
aserver.create(db_name)
db = aserver[db_name]
SECURITY[u'members'][u'names'] = security_users
if SECURITY != db.security:
LOGGER.info("Updating api db security", extra={'MESSAGE_ID': 'update_api_security'})
db.security = SECURITY
auth_doc = db.get(VALIDATE_DOC_ID, {'_id': VALIDATE_DOC_ID})
if auth_doc.get('validate_doc_update') != VALIDATE_DOC_UPDATE % username:
auth_doc['validate_doc_update'] = VALIDATE_DOC_UPDATE % username
LOGGER.info("Updating api db validate doc", extra={'MESSAGE_ID': 'update_api_validate_doc'})
db.save(auth_doc)
# sync couchdb views
sync_design(db)
db = server[db_name]
else:
if db_name not in server:
server.create(db_name)
db = server[db_name]
# sync couchdb views
sync_design(db)
config.registry.db = db
# migrate data
if not os.environ.get('MIGRATION_SKIP'):
migrate_data(config.registry.db)
# S3 connection
if 'aws.access_key' in settings and 'aws.secret_key' in settings and 'aws.s3_bucket' in settings:
connection = S3Connection(settings['aws.access_key'], settings['aws.secret_key'])
config.registry.s3_connection = connection
bucket_name = settings['aws.s3_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
config.registry.server_id = settings.get('id', '')
config.registry.health_threshold = float(settings.get('health_threshold', 99))
config.registry.update_after = asbool(settings.get('update_after', True))
return config.make_wsgi_app()
def includeme(config: Configurator) -> None:
config.include("pyramid_services")
config.add_directive("register_autowire", register_autowire)
def main(global_config, **settings):
config = Configurator(settings=settings, root_factory=RootFactory)
# adiciona metodos cross origin resource sharing (CORS)
config.add_directive('add_cors_preflight_handler',
add_cors_preflight_handler)
config.add_route_predicate('cors_preflight', CorsPreflightPredicate)
config.add_subscriber(add_cors_to_response, 'pyramid.events.NewResponse')
config.add_cors_preflight_handler()
# inclui dependencias
config.include('pyramid_jinja2')
config.include('pyramid_chameleon')
config.include('pyramid_sqlalchemy')
# escaneia views
config.scan()
# cria metadados de persistencia
metadata.create_all()
# adiciona rodas estaticas
# config.add_static_view(name='static', path='zapizza.site:static')
# todo: levar rotas para dentro de seus módulos
# registro
config.add_route('signup', '/signup')
config.add_route('confirm', '/confirm')
# login/logout
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('authenticated', '/authenticated')
# esqueci a senha
config.add_route('pass_forgot', '/forgot')
config.add_route('pass_reset', '/reset')
# /user
config.add_route('users_profile',
'/user/{username}/profile',
factory='.users.models.user_factory')
# /tamanhos
config.add_route('tamanhos',
'/tamanhos',
factory='.pizzas.tamanhos.models.tamanho_factory')
config.add_route('tamanhos_edit',
'/tamanhos/{hashid}',
factory='.pizzas.tamanhos.models.tamanho_factory')
config.add_route('tamanhos_enable',
'/tamanhos/{hashid}/enable',
factory='.pizzas.tamanhos.models.tamanho_factory')
# /sabores
config.add_route('sabores',
'/sabores',
factory='.pizzas.sabores.models.sabor_factory')
config.add_route('sabores_edit',
'/sabores/{hashid}',
factory='.pizzas.sabores.models.sabor_factory')
config.add_route('sabores_enable',
'/sabores/{hashid}/enable',
factory='.pizzas.sabores.models.sabor_factory')
# /bordas
config.add_route('bordas',
'/bordas',
factory='.pizzas.bordas.models.borda_factory')
config.add_route('bordas_edit',
'/bordas/{hashid}',
factory='.pizzas.bordas.models.borda_factory')
config.add_route('bordas_enable',
'/bordas/{hashid}/enable',
factory='.pizzas.bordas.models.borda_factory')
# /adicionais
config.add_route('adicionais',
'/adicionais',
factory='.adicionais.models.adicional_factory')
config.add_route('adicionais_edit',
'/adicionais/{hashid}',
factory='.adicionais.models.adicional_factory')
config.add_route('adicionais_enable',
'/adicionais/{hashid}/enable',
factory='.adicionais.models.adicional_factory')
# /clientes
config.add_route('clientes',
'/clientes',
factory='.clientes.models.cliente_factory')
config.add_route('clientes_edit',
'/clientes/{hashid}',
factory='.clientes.models.cliente_factory')
config.add_route('clientes_enable',
'/clientes/{hashid}/enable',
factory='.clientes.models.cliente_factory')
# /clientes/enderecos
config.add_route('enderecos',
'/clientes/{cliHashid}/enderecos',
factory='.clientes.enderecos.models.endereco_factory')
config.add_route('enderecos_edit',
'/clientes/{cliHashid}/enderecos/{endHashid}',
factory='.clientes.enderecos.models.endereco_factory')
# /clientes/telefones
config.add_route('telefones',
'/clientes/{cliHashid}/telefones',
factory='.clientes.telefones.models.telefone_factory')
config.add_route('telefones_edit',
'/clientes/{cliHashid}/telefones/{telHashid}',
factory='.clientes.telefones.models.telefone_factory')
# /pedidos
config.add_route('pedidos',
'/pedidos',
factory='.pedidos.models.pedido_factory')
config.add_route('pedidos_edit',
'/pedidos/{hashid}',
factory='.pedidos.models.pedido_factory')
config.add_route('pedidos_enable',
'/pedidos/{hashid}/enable',
factory='.pedidos.models.pedido_factory')
# Factory da sessao
session_secret = settings['session.secret']
session_factory = SignedCookieSessionFactory(session_secret)
config.set_session_factory(session_factory)
# Politicas de segurança
authn_policy = AuthTktAuthenticationPolicy(settings['auth.secret'],
callback=groupfinder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
# Objeto User disponivel como um atributo de Request
config.add_request_method(get_user, 'user', reify=True)
# cria aplicacao
return config.make_wsgi_app()
def main(argv=sys.argv):
if len(argv) != 3:
usage(argv)
config_uri = argv[1]
try:
num_users = int(argv[2])
except ValueError:
usage(argv)
setup_logging(config_uri)
settings = get_appsettings(config_uri)
config = Configurator(settings=settings)
config.add_directive('set_password_context', set_password_context)
db_session = init_sa(config)
logger = logging.getLogger('speak_friend.createusers')
if 'speak_friend.password_hasher' in settings:
config.include(settings['speak_friend.password_hasher'])
else:
from passlib.apps import ldap_context
config.set_password_context(context=ldap_context)
# makes the password_context available on the registry
config.commit()
pass_ctx = config.registry.password_context
user_num = 1
buf = StringIO()
cols = ['username', 'first_name', 'last_name', 'email', 'password_hash',
'password_salt', 'login_attempts', 'admin_disabled',
'is_superuser']
csv_file = csv.DictWriter(buf, cols, delimiter='\t', lineterminator='\n')
logger.info("Beginning to create %d users,", num_users)
cxn = db_session.connection()
cur = cxn.connection.cursor()
user_num += 0
user_passwords = {}
while user_num <= num_users:
first_name = u'Test'
last_name = pwgen(num_pw=1, pw_length=10, no_numerals=True,
no_symbols=True)
username = u'%s.%s' % (first_name, last_name)
password = pwgen(num_pw=1, pw_length=20)
user_passwords[username] = password
csv_file.writerow(dict(
username=username,
first_name=first_name,
last_name=last_name,
email=u'*****@*****.**' % username,
password_hash=pass_ctx.encrypt(password),
password_salt='',
login_attempts=0,
admin_disabled=False,
is_superuser=False,
))
logger.info("Created user %s, %04d/%04d.",
username, user_num, num_users)
user_num += 1
logger.info("Committing...")
tname = '%s.%s' % (UserProfile.__table__.schema,
UserProfile.__table__.name)
buf.seek(0)
cur.copy_from(buf, tname, columns=cols)
cxn.connection.commit()
for uname, pw in user_passwords.items():
print uname, pw
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
settings['available_locales'] = settings.get(
'available_locales', '').split()
static_prefix = settings.get('static_prefix', 'static')
config = Configurator(settings=settings)
config.include('pyramid_jinja2')
config.add_jinja2_search_path('oscad:templates')
config.include('oscad_i18n')
config.set_default_i18n_domain('oscad')
config.add_directive('set_toplevel_links', set_toplevel_links)
config.add_directive('add_toplevel_link', add_toplevel_link)
config.add_request_method(scss_path)
config.add_request_method(oscad_settings, property=True)
config.add_request_method(oslic_chapter_url)
config.add_renderer('scss', renderer_factory)
config.set_locale_negotiator(locale_negotiator)
config.set_session_factory(UnencryptedCookieSessionFactoryConfig(''))
config.add_subscriber('oscad.subscribers.add_renderer_globals',
'pyramid.events.BeforeRender')
config.add_subscriber('oscad.subscribers.jsonify',
'pyramid.events.NewRequest')
config.add_translation_dirs('oscad:locale')
config.add_route('scss', static_prefix + '/css/{css_path:.*}.css')
config.add_static_view(static_prefix, 'static', cache_max_age=3600)
config.add_static_view(
settings.get('bootstrap_location', static_prefix + '/bootstrap'),
'bootstrap')
config.add_static_view(
settings.get('jquery_location', static_prefix + '/jquery'),
'jquery')
config.registry.settings.oscad_settings = oscad_default_settings
config.add_route('index', '')
config.add_route('request', 'request')
config.add_route('matrix_request', 'matrix')
config.add_route('result', 'result')
config.add_route('imprint', 'imprint')
config.add_route('about', 'about')
config.add_route('help', 'help')
config.add_route('components', 'components')
config.add_route('change_language', 'language/{lang}')
config.add_route('translation_template', 'translations/oscad.pot')
config.add_route('translation_file', 'translations/{lang}')
if asbool(settings.get('allow_export')):
config.add_view('export', 'views:export')
config.add_route('export', 'export')
load_themes(config, settings)
config.scan()
config.commit()
jenv = config.get_jinja2_environment()
jenv.filters['htmlize'] = htmlize
jenv.undefined = jinja2.StrictUndefined
return config.make_wsgi_app()
config.add_route(route_name, path)
config.add_view(view, route_name=route_name)
discriminator = ('add_simple_view', path)
config.action(discriminator, callback, order=PHASE1_CONFIG)
class simple_view(object):
def __init__(self, path):
self.path = path
def register(self, scanner, name, wrapped):
scanner.config.add_simple_view(wrapped, self.path)
def __call__(self, wrapped):
venusian.attach(wrapped, self.register)
return wrapped
@simple_view("/hello/{name}")
def hello_world(request):
return Response('Hello %(name)s!' % request.matchdict)
if __name__ == '__main__':
config = Configurator()
config.add_directive("add_simple_view", add_simple_view)
config.scan(__name__)
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 8080, app)
server.serve_forever()
def get_default_config(global_config, base_config=None, **settings):
"""Provide a default configuration for a Petrel-based
application.
"""
if base_config is not None:
config = base_config
else:
zodb_uri = settings.get('zodb_uri', None) or \
global_config.get('zodb_uri', None)
if not zodb_uri:
raise ValueError("No 'zodb_uri' in application configuration.")
finder = PersistentApplicationFinder(zodb_uri, app_maker)
def get_root(request):
return finder(request.environ)
session_factory = session_factory_from_settings(settings)
config = Configurator(root_factory=get_root,
session_factory=session_factory,
settings=settings)
config.add_directive('register_template_api', _register_template_api)
config.add_directive('register_content_type', _register_content_type)
config.add_directive('customize_content_type', _customize_content_type)
## Register default content types
from petrel.content.document import Document
from petrel.content.file import File
from petrel.content.file import file_download
from petrel.content.folder import Folder
from petrel.content.folder import folder_contents
from petrel.content.folder import folder_delete
from petrel.content.folder import folder_rename
from petrel.content.folder import folder_rename_form
from petrel.content.image import Image
from petrel.content.site import Site
from petrel.views.admin import toolbar
## FIXME: look at the new cache_max_age argument
config.add_static_view(name='static-petrel', path='petrel:static')
config.register_content_type(Site, addable=False)
config.register_content_type(Document)
config.register_content_type(
File,
display_view=file_download)
config.register_content_type(
Image,
display_view=file_download)
config.register_content_type(Folder)
config.add_view(name='contents',
context=IFolderish,
view=folder_contents,
renderer='templates/folder_contents.pt')
config.add_view(name='folder_action_handler',
context='petrel.interfaces.IFolderish',
request_param="action=delete",
view=folder_delete)
config.add_view(name='folder_action_handler',
context='petrel.interfaces.IFolderish',
request_param='action=rename',
view=folder_rename_form,
renderer='templates/folder_rename.pt')
config.add_view(name='rename',
context='petrel.interfaces.IFolderish',
view=folder_rename)
config.add_view(name='_toolbar.html',
renderer='petrel:templates/toolbar.pt',
view=toolbar)
## Register default subscribers
from repoze.folder.interfaces import IObjectAddedEvent
from repoze.folder.interfaces import IObjectWillBeRemovedEvent
from petrel.search import index
from petrel.search import reindex
from petrel.search import unindex
from petrel.interfaces import IObjectModifiedEvent
config.add_subscriber(index, IObjectAddedEvent)
config.add_subscriber(reindex, IObjectModifiedEvent)
config.add_subscriber(unindex, IObjectWillBeRemovedEvent)
## Enable authorization system and related views
from petrel.auth import setup_who_api_factory
from petrel.views.auth import login
from petrel.views.auth import login_form
from petrel.views.auth import logout
setup_who_api_factory(global_config, settings['auth_config_file'])
config.add_view(name='login',
renderer='petrel:templates/login.pt',
view=login_form)
config.add_view(name='login',
request_method='POST',
renderer='petrel:templates/login.pt',
view=login)
config.add_view(name='logout',
view=logout)
return config
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)
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'})
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,
}.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('legal', '/legal', lambda r: {}, renderer='legal.mako')
config.add_route_and_view('download', '/download', lambda r: {}, renderer='download.mako')
config.add_route_and_view('contact', '/contact', lambda r: {}, renderer='contact.mako')
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('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.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()
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('%s:locale' % config.package_name)
config.add_translation_dirs('clld:locale')
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)
for utility, interface in utilities:
config.registry.registerUtility(utility, interface)
return config
def _makeOne(self, autocommit=True):
from pyramid.config import Configurator
from pyramid_handlers import add_handler
config = Configurator(autocommit=autocommit)
config.add_directive('add_handler', add_handler)
return config
config.add_view(view, route_name=route_name)
discriminator = ('add_simple_view', path)
config.action(discriminator, callback, order=PHASE1_CONFIG)
class simple_view(object):
def __init__(self, path):
self.path = path
def register(self, scanner, name, wrapped):
scanner.config.add_simple_view(wrapped, self.path)
def __call__(self, wrapped):
venusian.attach(wrapped, self.register)
return wrapped
@simple_view("/hello/{name}")
def hello_world(request):
return Response('Hello %(name)s!' % request.matchdict)
if __name__ == '__main__':
config = Configurator()
config.add_directive("add_simple_view", add_simple_view)
config.scan(__name__)
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 8080, app)
server.serve_forever()
def main(global_config, **settings):
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
authn_policy = SessionAuthenticationPolicy(callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory=RootFactory,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory)
config.include('pyramid_jinja2')
add_jinja2_extension(config, ext.do)
add_jinja2_extension(config, ext.loopcontrols)
add_jinja2_extension(config, SelectiveHTMLCompress)
add_jinja2_search_path(config, 'alchemist:templates')
add_jinja2_search_path(config, 'alchemist:templates/layout')
add_jinja2_search_path(config, 'alchemist:templates/helpers')
add_jinja2_search_path(config, 'alchemist:templates/auth')
add_jinja2_search_path(config, 'alchemist:templates/company')
add_jinja2_search_path(config, 'alchemist:templates/blocks')
add_jinja2_search_path(config, 'alchemist:templates/helpers')
config.include('pyramid_dogpile_cache')
cache = get_region('main')
config.include('pyramid_mailer')
def add_path(config, view, path, **kwargs):
route_name = '%s_%s' % (qualname(view), path.replace('/', '_').split('{')[0])
config.add_route(route_name, path)
config.add_view(view, route_name=route_name, **kwargs)
config.add_directive('add_path', add_path)
def get_user(request):
id = authenticated_userid(request)
if not id:
return None
return User.bid(id)
config.add_request_method(get_user, 'user', reify=True)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('export-dumps', 'export-dumps', cache_max_age=3600)
config.add_static_view('img', 'static/img', cache_max_age=3600)
config.add_static_view('css', 'static/css', cache_max_age=3600)
config.add_static_view('js', 'static/js', cache_max_age=3600)
config.add_static_view('fonts', 'static/fonts', cache_max_age=3600)
config.add_static_view('upload', 'upload', cache_max_age=3600)
from alchemist import routes_admin
from alchemist import routes_other
from alchemist import routes_auth
from alchemist import routes_user
config.include(routes_admin.includeme)
config.include(routes_other.includeme)
config.include(routes_auth.includeme)
config.include(routes_user.includeme)
config.scan('alchemist.views.system')
return config.make_wsgi_app()
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
