def settings_view(request):
settings_all = dict(DBSession.query(Settings.key, Settings).all())
if request.method == 'POST':
for key, value in request.POST.iteritems():
if 'drive_id' in key:
settings_all[key[:-9]].drive_id = value
elif key in settings_all:
settings_all[key].value = value
Settings.set_docs_vals(settings_all)
Settings._cache = {}
get_region('main').invalidate()
settings = {}
settings['urls'], settings['general'], settings['drive_ids'] = [{} for x in range(3)]
for k, v in settings_all.iteritems():
if 'http' in v.value:
settings['urls'][k] = v.value
if 'google' in v.value or v.drive_id:
settings['drive_ids'][k] = v.drive_id or ''
else:
settings['general'][k] = v.value
return {
'settings_general': settings['general'],
'settings_urls': settings['urls'],
'settings_drive_ids': settings['drive_ids']
}
def test_get_region(self):
from pyramid_dogpile_cache import includeme, regions, default_settings, region_settings_dict, get_region
includeme(self.config)
region = get_region('aaa')
self.assertEqual(region.name, 'aaa')
self.assertEqual(region.factory_args, {})
self.assertEqual(region.config['backend'], 'memory')
self.assertEqual(region.config['expire'], '10')
region = get_region('bbb')
self.assertEqual(region.name, 'bbb')
self.assertEqual(region.factory_args,
{'function_key_generator': dummy})
self.assertEqual(region.config['backend'], 'memory')
self.assertEqual(region.config['expire'], '10')
self.assertEqual(region.config['foo'], 'foo')
self.assertEqual(region.config['foo.bar'], 'foo.bar')
region = get_region('ccc')
self.assertEqual(region.name, 'ccc')
self.assertEqual(region.factory_args, {})
self.assertEqual(region.config['backend'], 'file')
self.assertEqual(region.config['expire'], '10')
region = get_region('ddd')
self.assertEqual(region.name, 'ddd')
self.assertEqual(region.factory_args, {})
self.assertEqual(region.config['backend'], 'memory')
self.assertEqual(region.config['expire'], '10')
def test_get_region(self):
from pyramid_dogpile_cache import includeme, regions, default_settings, region_settings_dict, get_region
includeme(self.config)
region = get_region('aaa')
self.assertEqual(region.name, 'aaa')
self.assertEqual(region.factory_args, {})
self.assertEqual(region.config['backend'], 'memory')
self.assertEqual(region.config['expire'], '10')
region = get_region('bbb')
self.assertEqual(region.name, 'bbb')
self.assertEqual(region.factory_args, { 'function_key_generator': dummy })
self.assertEqual(region.config['backend'], 'memory')
self.assertEqual(region.config['expire'], '10')
self.assertEqual(region.config['arguments.foo'], 'foo')
self.assertEqual(region.config['arguments.foo.bar'], 'foo.bar')
region = get_region('ccc')
self.assertEqual(region.name, 'ccc')
self.assertEqual(region.factory_args, {})
self.assertEqual(region.config['backend'], 'file')
self.assertEqual(region.config['expire'], '10')
self.assertEqual(region.config['arguments.foo'], 'FOO')
region = get_region('ddd')
self.assertEqual(region.name, 'ddd')
self.assertEqual(region.factory_args, {})
self.assertEqual(region.config['backend'], 'memory')
self.assertEqual(region.config['expire'], '10')
self.assertEqual(region.config['arguments.foo'], 'FOO')
def cache_safe(region='main', namespace=None,
expiration_time=None,
should_cache_fn=None,
function_key_generator=None
):
cache = get_region(region)
if function_key_generator is None:
function_key_generator = gen_cache_key_args_safe
decorator = cache.cache_on_arguments(namespace, expiration_time, should_cache_fn,
function_key_generator=function_key_generator)
def run(func):
cached_decorator = decorator(func)
@wraps(func)
def safe_decorator(*args, **kwargs):
try:
return cached_decorator(*args, **kwargs)
except:
# logging.error('Cache down!', exc_info=1)
return func(*args, **kwargs)
return safe_decorator
return run
def mark_unwanted(request):
unwanted_user = int(request.matchdict.get('user_id'))
weekly_focus = request.user.weekly_focus.lower().replace(' ', '_')
rp = request.POST.get
DBSession.add(UnWanted(by_user=request.user, user_id=unwanted_user,
weekly_focus=weekly_focus, connected=rp('connected') == 'true',
rating=rp('rating'), feedback=rp('feedback')))
cache = get_region('main')
cache.invalidate()
return HTTPFound(request.referer or '/')
def create_cache(name):
ch = None
if force_redis:
ch = make_region().configure('dogpile.cache.redis',
arguments=force_redis)
else:
try:
ch = get_region(name)
except:
ch = make_region().configure('dogpile.cache.memory')
warnings.warn(
"Warning: cache objects are in memory, are you creating docs?")
ch.key_mangler = my_key_mangler(name)
return ch
ctx_instance_class=Discussion, permission=P_READ,
accept="application/json", name="settings",
renderer='json')
def discussion_settings_get(request):
return request.context._instance.settings_json
@view_config(context=InstanceContext, request_method='PUT',
ctx_instance_class=Discussion, permission=P_ADMIN_DISC,
header=JSON_HEADER, name="settings")
def discussion_settings_put(request):
request.context._instance.settings_json = request.json_body
return HTTPOk()
discussion_jsonld_cache = get_region('discussion_jsonld')
userprivate_jsonld_cache = get_region('userprivate_jsonld')
@discussion_jsonld_cache.cache_on_arguments()
def discussion_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
return aqsm.as_jsonld(discussion_id)
@userprivate_jsonld_cache.cache_on_arguments()
def userprivate_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
cg = aqsm.participants_private_as_graph(discussion_id)
return aqsm.graph_as_jsonld(cg)
name="settings")
@view_config(context=InstanceContext,
request_method='PUT',
ctx_instance_class=Discussion,
permission=P_ADMIN_DISC,
header=JSON_HEADER,
name="settings")
def discussion_settings_put(request):
request.context._instance.settings_json = request.json_body
return HTTPOk()
dogpile_fname = join(dirname(dirname(dirname(dirname(__file__)))),
get_config().get('dogpile_cache.arguments.filename'))
discussion_jsonld_cache = get_region('discussion_jsonld',
**{"arguments.filename": dogpile_fname})
userprivate_jsonld_cache = get_region('userprivate_jsonld',
**{"arguments.filename": dogpile_fname})
@discussion_jsonld_cache.cache_on_arguments()
def discussion_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
return aqsm.as_jsonld(discussion_id)
@userprivate_jsonld_cache.cache_on_arguments()
def userprivate_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
from urllib.parse import unquote_plus
from pyramid.view import view_config
from pyramid.httpexceptions import HTTPBadRequest, HTTPNotFound, HTTPFound
from pyramid.response import Response
from pygments import highlight
from pygments.filters import Filter
from pygments import token
from pygments.lexer import RegexLexer
from pygments.lexers import get_lexer_for_filename
from pygments.formatters.svg import SvgFormatter, escape_html
from pyramid_dogpile_cache import get_region
from .git import Symbolic
from .interfaces import IGitFetcher
cache_region = get_region(__name__)
def eaw_len(ustr):
return sum(2 if unicodedata.east_asian_width(uc) in ('W', 'A') else 1 for uc in ustr)
def extract_callouts(code):
callouts = []
result = []
for l, line in enumerate(re.split(ur'\r\n|\n|\r', code)):
g = re.search(ur'\s+<---+\s*\((\d+)\)\s*$', line)
if g is not None:
line = line[:-len(g.group(0))]
callouts.append((l, g.group(1)))
result.append(line)
return u'\n'.join(result), callouts
ctx_instance_class=Discussion, permission=P_READ,
accept="application/json", name="settings",
renderer='json')
def discussion_settings_get(request):
return request.context._instance.settings_json
@view_config(context=InstanceContext, request_method='PUT',
ctx_instance_class=Discussion, permission=P_ADMIN_DISC,
header=JSON_HEADER, name="settings")
def discussion_settings_put(request):
request.context._instance.settings_json = request.json_body
return HTTPOk()
jsonld_cache = get_region('jsonld')
@jsonld_cache.cache_on_arguments()
def create_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
return aqsm.as_jsonld(discussion_id)
@view_config(context=InstanceContext, name="jsonld",
ctx_instance_class=Discussion, request_method='GET',
permission=P_READ, accept="application/ld+json")
@view_config(context=InstanceContext,
ctx_instance_class=Discussion, request_method='GET',
permission=P_READ, accept="application/ld+json")
from babel.numbers import format_currency
from babel.dates import format_datetime
from mako.exceptions import TopLevelLookupException
from pyramid.view import view_config, view_defaults, notfound_view_config
from pyramid.renderers import render_to_response, render
from pyramid.httpexceptions import HTTPBadRequest, HTTPNotFound
from pyramid_dogpile_cache import get_region
from price_watch.models import (Page, PriceReport, PackageLookupError,
CategoryLookupError, ProductCategory, Product,
ProductPackage, Merchant)
from price_watch.utilities import multidict_to_list
from price_watch.exceptions import MultidictError
MULTIPLIER = 1
general_region = get_region('general')
def namespace_predicate(class_):
"""
Custom predicate to check context for being a namespace
"""
def check_namespace(context, request):
try:
return context == request.root[class_.namespace]
except KeyError:
return False
return check_namespace
def get_datetimes(days):
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()
@view_config(context=InstanceContext, request_method='PATCH',
ctx_instance_class=Discussion, permission=P_ADMIN_DISC,
header=JSON_HEADER, name="settings")
@view_config(context=InstanceContext, request_method='PUT',
ctx_instance_class=Discussion, permission=P_ADMIN_DISC,
header=JSON_HEADER, name="settings")
def discussion_settings_put(request):
request.context._instance.settings_json = request.json_body
return HTTPOk()
dogpile_fname = join(
dirname(dirname(dirname(dirname(__file__)))),
get_config().get('dogpile_cache.arguments.filename'))
discussion_jsonld_cache = get_region(
'discussion_jsonld', **{"arguments.filename": dogpile_fname})
userprivate_jsonld_cache = get_region(
'userprivate_jsonld', **{"arguments.filename": dogpile_fname})
@discussion_jsonld_cache.cache_on_arguments()
def discussion_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
return aqsm.as_jsonld(discussion_id)
@userprivate_jsonld_cache.cache_on_arguments()
def userprivate_jsonld(discussion_id):
from assembl.semantic.virtuoso_mapping import AssemblQuadStorageManager
aqsm = AssemblQuadStorageManager()
# coding=utf8
import time
import cPickle
from hashlib import md5
from dogpile.cache.api import NoValue
from pyramid_dogpile_cache import get_region
from tap.service.common import conn_get
from tap.service.interpreter import ParaHandler
tap_cache = get_region('tap')
def get_val(key, expire):
data = tap_cache.get(key, expiration_time=expire)
if isinstance(data, NoValue):
return None
return data
def set_val(key, value):
return tap_cache.set(key, value)
def _persistence_db(dbtype, connstring, options):
# 只支持 MongoDB
from babel.numbers import format_currency
from babel.dates import format_datetime
from mako.exceptions import TopLevelLookupException
from pyramid.view import view_config, view_defaults, notfound_view_config
from pyramid.renderers import render_to_response, render
from pyramid.httpexceptions import HTTPBadRequest, HTTPNotFound
from pyramid_dogpile_cache import get_region
from price_watch.models import (Page, PriceReport, PackageLookupError,
CategoryLookupError, ProductCategory, Product,
ProductPackage, Merchant)
from price_watch.utilities import multidict_to_list
from price_watch.exceptions import MultidictError
MULTIPLIER = 1
general_region = get_region('general')
def namespace_predicate(class_):
"""
Custom predicate to check context for being a namespace
"""
def check_namespace(context, request):
try:
return context == request.root[class_.namespace]
except KeyError:
return False
return check_namespace
