def includeme(config): settings = config.get_settings() for key, value in settings.iteritems(): if not key.startswith('static.'): continue path, url = aslist(value) config.add_static_view(name=url, path=path) view_config(route_name=key)(staticRedirectView) config.add_route(key, url)
def __init_subclass__(cls, **kwargs): """Register routes""" super().__init_subclass__(**kwargs) route_name = cls.route kwargs = dict(renderer='json', route_name=route_name) cls.get = view_config(request_method='GET', **kwargs)(cls.get) cls.post = view_config(request_method='POST', **kwargs)(cls.post) cls.routing = { 'get': {'request_method': 'GET', 'route_name': route_name}, 'post': {'request_method': 'POST', 'route_name': route_name}, }
def includeme(config): """Setup swagger ui swagger_ui.url: URL at which the swagger ui should be accessable swagger-ui will not be available if not provided or empty """ settings = config.get_settings() swagger_url = settings.get('swagger_ui.url') if swagger_url: view_config(route_name='swagger-ui', renderer='index.jinja2' )(swaggerUIView) config.add_route('swagger-ui', swagger_url) config.add_static_view(name='/%s_resources/' % swagger_url, path='iris.service:swaggerui/dist')
def api_config(**kwargs): """Extend Pyramid's @view_config decorator with modified defaults.""" config = { 'accept': 'application/json', 'renderer': 'json', } config.update(kwargs) return view_config(**config)
def __call__(self, cls): for method, route in self.routing.items(): if hasattr(cls, method): cls = view_config(attr=method, **self.kwargs, **route) else: self.routing.pop(method) cls.routing = self.routing return cls
def __init__(self, **settings): method = self.__class__.__name__.split('_')[0].upper() super(_rest_view, self).__init__(request_method=method, **settings) # add CORS OPTIONS method support for registered REST view route_name = settings['route_name'] if route_name in self.cors_route: self.cors_route[route_name].add_method(method) return handler = PrefligthHandlerFactory(route_name, method) self.cors_route[route_name] = handler view_config(request_method='OPTIONS', route_name=route_name, _depth=1)(handler) # dirty hack # to get caller's module, in order to inject preflight_handler to that module # so when scan configuration, pyramid will pick OPTIONS for that route module = inspect.getmodule(inspect.getouterframes(inspect.currentframe())[0][0].f_back) setattr(module, 'preflight_'+route_name, handler)
def __init__(self, **settings): method = self.__class__.__name__.split('_')[0].upper() super(_rest_view, self).__init__(request_method=method, **settings) # add CORS OPTIONS method support for registered REST view route_name = settings['route_name'] if route_name in self.cors_route: self.cors_route[route_name].add_method(method) return handler = PrefligthHandlerFactory(route_name, method) self.cors_route[route_name] = handler view_config(request_method='OPTIONS', route_name=route_name, _depth=1)(handler) # dirty hack # to get caller's module, in order to inject preflight_handler to that module # so when scan configuration, pyramid will pick OPTIONS for that route module = inspect.getmodule( inspect.getouterframes(inspect.currentframe())[0][0].f_back) setattr(module, 'preflight_' + route_name, handler)
def __call__(self, wrapped): method = self.method or wrapped.__name__ kw = self.kw.copy() def xmlrpc_method_predicate(context, request): return getattr(request, "rpc_method", None) == method predicates = kw.setdefault("custom_predicates", []) predicates.append(xmlrpc_method_predicate) return view_config(**kw)(wrapped)
def api_config(**settings): """ A view configuration decorator with defaults. JSON in and out. CORS with tokens and client id but no cookie. """ settings.setdefault('accept', 'application/json') settings.setdefault('renderer', 'json') settings.setdefault('decorator', cors_policy) return view_config(**settings)
def api_config(**kwargs): """Pyramid's @view_config decorator but with modified defaults""" config = { # The containment predicate ensures we only respond to API calls 'containment': 'h.resources.APIResource', 'accept': 'application/json', 'renderer': 'json', } config.update(kwargs) return view_config(**config)
def __call__(self, wrapped, view_config=view_config): # view_config passable for unit testing purposes only method_name = self.method or wrapped.__name__ try: # pyramid 1.1 from pyramid.renderers import null_renderer renderer = null_renderer except ImportError: # pragma: no cover # pyramid 1.0 renderer = None return view_config(route_name=self.route_name, name=method_name, renderer=renderer)(wrapped)
def __call__(self, wrapped): view_config.venusian = self.venusian method_name = self.method or wrapped.__name__ try: # pyramid 1.1 from pyramid.renderers import null_renderer renderer = null_renderer except ImportError: # pyramid 1.0 renderer = None return view_config(route_name=self.route_name, name=method_name, renderer=renderer)(wrapped)
def hybrid_view_decorator(view_callable): def hybrid_view_callable(*inner_args): if len(inner_args) > 1: request = inner_args[1] else: request = inner_args[0] print 'monkey patched', str(len(inner_args)) request.hybrid_url = hybrid_url print request print request.hybrid_url return view_callable(*inner_args) return view_config(*args, **kwargs)(hybrid_view_callable)
def ic_view_config(**kwargs: Any) -> Callable: """Wrap the @view_config decorator for Intercooler views.""" if 'route_name' in kwargs: kwargs['route_name'] = 'ic_' + kwargs['route_name'] if 'renderer' in kwargs: kwargs['renderer'] = 'intercooler/' + kwargs['renderer'] if 'header' in kwargs: raise ValueError("Can't add a header check to Intercooler view.") kwargs['header'] = 'X-IC-Request:true' return view_config(**kwargs)
def ic_view_config(**kwargs: Any) -> Callable: """Wrap the @view_config decorator for Intercooler views.""" if "route_name" in kwargs: kwargs["route_name"] = "ic_" + kwargs["route_name"] if "renderer" in kwargs: kwargs["renderer"] = "intercooler/" + kwargs["renderer"] if "header" in kwargs: raise ValueError("Can't add a header check to Intercooler view.") kwargs["header"] = "X-IC-Request:true" return view_config(**kwargs)
def __call__(self, **settings): new_settings = {} new_settings.update(self.__config_defaults) new_settings.update(settings) new_settings.setdefault('custom_predicates', []) predicates = new_settings['custom_predicates'] predicates.append(self.lookup_records) if 'permit' in new_settings: predicates.append(new_settings.pop('permit')) permit = self.__permits.get(new_settings.get('request_method', 'GET')) if permit: predicates.append(permit) return view_config(**new_settings)
def api_config(**settings): """ A view configuration decorator with defaults. JSON in and out. CORS with tokens and client id but no cookie. """ settings.setdefault('accept', 'application/json') settings.setdefault('renderer', 'json') settings.setdefault('decorator', cors_policy) request_method = settings.get('request_method', ()) if not isinstance(request_method, tuple): request_method = (request_method,) if len(request_method) == 0: request_method = ('DELETE', 'GET', 'HEAD', 'POST', 'PUT',) settings['request_method'] = request_method + ('OPTIONS',) return view_config(**settings)
def __call__(self, cls): cls.item_route = self.route if self.route: cls = view_config(_depth=1, renderer='json', attr='read_item', request_method='GET', route_name=self.route)(cls) cls = view_config(_depth=1, renderer='json', attr='update_item', request_method='PUT', route_name=self.route)(cls) cls = view_config(_depth=1, renderer='json', attr='delete_item', request_method='DELETE', route_name=self.route, permission='super')(cls) cls = view_config(_depth=1, renderer='json', attr='options_info', request_method='OPTIONS', route_name=self.route)(cls) if self.collection_route: cls = view_config(_depth=1, renderer='json', attr='list_items', request_method='GET', route_name=self.collection_route)(cls) cls = view_config(_depth=1, renderer='json', attr='create_item', request_method='POST', route_name=self.collection_route)(cls) cls = view_config(_depth=1, renderer='json', attr='options_info', request_method='OPTIONS', route_name=self.collection_route)(cls) return cls
def view(self, **view_settings): effective_settings = self._default_settings.copy() effective_settings.update(view_settings) return view_config(**effective_settings)
renderer='__main__:templates/index.mako') def test_predicates(request): return {'title': 'Test route predicates'} @view_config(route_name='test_chameleon_exc', renderer='__main__:templates/error.pt') @view_config(route_name='test_mako_exc', renderer='__main__:templates/error.mako') def test_template_exc(request): return {'title': 'Test template exceptions'} if pyramid_jinja2 is not None: test_template_exc = view_config( route_name='test_jinja2_exc', renderer='__main__:templates/error.jinja2')(test_template_exc) class DummyRootFactory(object): def __init__(self, request): self.request = request def __getitem__(self, name): return self if __name__ == '__main__': # configuration settings try: # ease testing py2 and py3 in same directory
def json_view(**settings): """A view configuration decorator with JSON defaults.""" settings.setdefault("accept", "application/json") settings.setdefault("renderer", "json") return view_config(**settings)
if order_by is not None: models = models.order_by(order_by) c.models = models def success_redirect(c, message=None, route_name=None): c.request.session.flash(message.format(obj=c.obj)) return HTTPFound(c.request.route_url(route_name)) def add_form(c, form): c.form = form.format(action=c.request.current_route_path(), method="POST") #fixme loop = (view_loop() .add(partial(create_model, model=User)) .add(partial(add_session)) .add(partial(success_redirect, message="user: {obj.name} is created.", route_name="user.create")) ) user_create = view_config(route_name="user.create", request_method="POST", renderer='input.mako')(ViewFromLoopForLazy(loop, "create_user")) user_form = """ <form action="{action}" method="{method}"> <input name="name" type="text" value=""/> <input type="submit"/> </form> """ loop = (view_loop() .add(partial(get_model_list, model=User, order_by=sa.asc(User.name))) .add(partial(add_form, form=user_form)) ) user_create_input = view_config(route_name="user.create", request_method="GET", renderer='input.mako')(ViewFromLoopForLazy(loop, "create_user_input"))
return Response('{"message": "you do not have the permission to view other users\' profiles"}', status='403 Forbidden') profile = first(filter(lambda p: p.id==requested_user_id, user_profile_db)) if profile: if request.method == 'POST': new_data = dict(filter(lambda tp: tp[0] in (u'suite_number', u'lease_until'), request.json_body.iteritems())) new_profile = profile._replace(**new_data) user_profile_db.remove(profile) user_profile_db.append(new_profile) profile = new_profile return Response(json.dumps(profile.serialize())) else: return Response('{}') view_config(route_name='user_profile', request_method='POST')(get_user_profile) class AuthError(RuntimeError): pass @view_config(route_name='authenticate_and_login', request_method='POST') @json_response @csrf_protected def authenticate_and_login(request): auth_details = AuthDetails(**request.json_body) request.session['user_id'] = None user_data = first(filter(lambda u: u.username == auth_details.username, user_db)) try: if not user_data: raise AuthError("invalid username") if bcrypt.hashpw(str(auth_details.password), user_data.password_hash) != \
def json_view(**settings): """A view configuration decorator with JSON defaults.""" settings.setdefault('accept', 'application/json') settings.setdefault('renderer', 'json') return view_config(**settings)
@srpc(String, Integer, _returns=Iterable(String)) def say_hello(name, times): ''' Docstrings for service methods appear as documentation in the wsdl <b>what fun</b> @param name the name to say hello to @param the number of times to say hello @return the completed array ''' for i in range(times): yield 'Hello, %s' % name # view soapApp = view_config(route_name="home")(pyramid_soap11_application( [HelloWorldService], tns)) if __name__ == '__main__': # configuration settings settings = {} settings['debug_all'] = True # configuration setup config = Configurator(settings=settings) # routes setup config.add_route('home', '/') config.scan() # serve app app = config.make_wsgi_app() server = make_server('0.0.0.0', 7789, app) server.serve_forever()
self.request = request def __call__(self, *args, **kwargs): return Response("hello") # 还有下面这种奇葩的使用方式(我想你在项目中肯定不会这样写的) class MyView2: def __init__(self, request): self.request = request def __call__(self, *args, **kwargs): return Response("Hello2") my_view2 = view_config(route_name="hello")(MyView2) # 多个 view_config 修饰同一个函数, 这样路由 edit 和 change 都会调用 edit 函数 @view_config(route_name="edit") @view_config(route_name="change") def edit(request): return Response("edited!") # 直接修饰类的方法 class MyView3: def __init__(self, request): self.request = request @view_config(route_name="hello3")
def api(name, action, renderer='json'): return view_config(**_conf(name, action, renderer))
@srpc(String, Integer, _returns=Iterable(String)) def say_hello(name, times): ''' Docstrings for service methods appear as documentation in the wsdl <b>what fun</b> @param name the name to say hello to @param the number of times to say hello @return the completed array ''' for i in range(times): yield 'Hello, %s' % name # view soapApp = view_config(route_name="home")( pyramid_soap11_application([HelloWorldService], tns)) if __name__ == '__main__': # configuration settings settings = {} settings['debug_all'] = True # configuration setup config = Configurator(settings=settings) # routes setup config.add_route('home', '/') config.scan() # serve app app = config.make_wsgi_app() server = make_server('0.0.0.0', 8000, app) server.serve_forever()
def act(action, renderer='json'): filename = sys._getframe().f_back.f_code.co_filename return view_config(**_conf(service(filename), action, renderer))
from sqlalchemy.exc import DBAPIError from .models import ( DBSession, MyModel, ) {% endif %} {% if cookiecutter.persistence == 'zodb' %} from .models import MyModel {% endif %} {% if cookiecutter.persistence == 'zodb' -%} @view_config(context=MyModel, {% else -%} @view_config(route_name='home', {% endif -%} {% if cookiecutter.template_engine == 'chameleon' -%}renderer='templates/mytemplate.pt'){% endif -%} {% if cookiecutter.template_engine == 'jinja2' -%}renderer='templates/mytemplate.jinja2'){% endif -%} {% if cookiecutter.template_engine == 'mako' -%}renderer='templates/mytemplate.mako'){% endif %} def my_view(request): {% if cookiecutter.persistence != 'sqlalchemy' %} return {'project': '{{ cookiecutter.project_name }}'} {% else %} try: one = DBSession.query(MyModel).filter(MyModel.name == 'one').first() except DBAPIError: return Response(conn_err_msg, content_type='text/plain', status_int=500) return {'one': one, 'project': '{{ cookiecutter.project_name}}'}
return {} @view_config(route_name='test_predicates', renderer='__main__:templates/index.mako') def test_predicates(request): return {'title':'Test route predicates'} @view_config(route_name='test_chameleon_exc', renderer='__main__:templates/error.pt') @view_config(route_name='test_mako_exc', renderer='__main__:templates/error.mako') def test_template_exc(request): return {'title':'Test template exceptions'} if pyramid_jinja2 is not None: test_template_exc = view_config( route_name='test_jinja2_exc', renderer='__main__:templates/error.jinja2')( test_template_exc) class DummyRootFactory(object): def __init__(self, request): self.request = request def __getitem__(self, name): return self if __name__ == '__main__': # configuration settings try: # ease testing py2 and py3 in same directory shutil.rmtree(os.path.join(here, 'mako_modules')) except:
def __call__(self, wrapped): view_config.venusian = self.venusian method_name = self.method or wrapped.__name__ return view_config(route_name=self.route_name, name=method_name)(wrapped)
@view_config(name='stacked2') @view_config(name='stacked1') def stacked(context, request): return 'stacked' class stacked_class(object): def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'stacked_class' stacked_class = view_config(name='stacked_class1')(stacked_class) stacked_class = view_config(name='stacked_class2')(stacked_class) class oldstyle_grokked_class: def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'oldstyle_grokked_class' oldstyle_grokked_class = view_config( name='oldstyle_grokked_class')(oldstyle_grokked_class)
def api_config(login_required=True, *args, **kwargs): decorators = [] if login_required: decorators.append(login_required_decorator) return view_config(decorator=decorators, *args, **kwargs)
return 'grokked_post' @view_config(name='stacked2', renderer=null_renderer) @view_config(name='stacked1', renderer=null_renderer) def stacked(context, request): return 'stacked' class stacked_class(object): def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'stacked_class' stacked_class = view_config(name='stacked_class1', renderer=null_renderer)(stacked_class) stacked_class = view_config(name='stacked_class2', renderer=null_renderer)(stacked_class) class oldstyle_grokked_class: def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'oldstyle_grokked_class' oldstyle_grokked_class = view_config(name='oldstyle_grokked_class', renderer=null_renderer)( oldstyle_grokked_class)
@view_config(name='stacked2', renderer=null_renderer) @view_config(name='stacked1', renderer=null_renderer) def stacked(context, request): return 'stacked' class stacked_class(object): def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'stacked_class' stacked_class = view_config(name='stacked_class1', renderer=null_renderer)(stacked_class) stacked_class = view_config(name='stacked_class2', renderer=null_renderer)(stacked_class) class oldstyle_grokked_class: def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'oldstyle_grokked_class' oldstyle_grokked_class = view_config( name='oldstyle_grokked_class',
import json def server_error(exc: Exception, request: Request) -> Response: """View overriding default 500 error page. :param exc: A 500 exception :param request: A request object :returns: A response object with a application/json formatted body """ try: payload = request.json_body except json.JSONDecodeError: payload = {} logger.error( f'{exc.__class__.__name__} occurred on url {request.url}', extra={'payload': payload}, exc_info=exc ) msg = 'Something went terribly wrong and now we need to wake up a sysadmin' body = {'status': 'error', 'message': msg, 'url': request.url} response = Response(json.dumps(body)) response.status_int = 500 response.content_type = 'application/json' return response if ENV not in ('test', 'development'): server_error = view_config(context=Exception)(server_error)
#Pyramid is not designed to allow you to add view configurations programatically. #But in Python all things are possible. Here is a way to set up view configurations in a loop. #This will declare the functions "set_server_to_Boosting", etc... #And bind them to the routes "server_Boosting" and "server_by_id_Boosting" ### Here are the states that can only be set by agents... for state in [ 'Stopped', 'Started', 'Prepared', 'Pre_Deboosted', 'Boosting', 'Deboosting', 'Starting_Boosted' ]: funcname = 'set_server_to_' + state globals()[funcname] = lambda request, state=state: _set_server_state( request, state) globals()[funcname] = view_config( request_method="POST", routes=['server_' + state, 'server_by_id_' + state], renderer='json', permission="act")(globals()[funcname]) globals()[funcname].__name__ = funcname globals()[funcname].__qualname__ = funcname ### States that any user can put their server into... for state in ['Starting', 'Stopping', 'Restarting', 'Error']: funcname = 'set_server_to_' + state globals()[funcname] = lambda request, state=state: _set_server_state( request, state) globals()[funcname] = view_config( request_method="POST", routes=['server_' + state, 'server_by_id_' + state], renderer='json', permission="use")(globals()[funcname])
from pyramid.view import view_config from marlton.interfaces import IWebSite from marlton.utils import API @view_config(for_=IWebSite, name='videos', permission='view', renderer='marlton.views:templates/videos.pt') def videos_view(context, request): return dict( api = API(context, request), ) for x in range(1, 11): # add groundhog1 - 10 urls gh_view = view_config(for_=IWebSite, name='groundhog%s' % x, permission='view', renderer='marlton.views:templates/videos.pt') videos_view = gh_view(videos_view)
return 'grokked_post' @view_config(name='stacked2') @view_config(name='stacked1') def stacked(context, request): return 'stacked' class stacked_class(object): def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'stacked_class' stacked_class = view_config(name='stacked_class1')(stacked_class) stacked_class = view_config(name='stacked_class2')(stacked_class) class oldstyle_grokked_class: def __init__(self, context, request): self.context = context self.request = request def __call__(self): return 'oldstyle_grokked_class' oldstyle_grokked_class = view_config(name='oldstyle_grokked_class')( oldstyle_grokked_class) class grokked_class(object): def __init__(self, context, request):
def auth_view(**settings): settings.setdefault('accept', 'text/html') settings.setdefault('renderer', 'h:templates/auth.html.jinja2') return view_config(**settings)
"""Basic function for putting a server into some state, for basic state-change calls.""" vm_id, actor_id = _resolve_vm(request) return {"vm_id": vm_id, "touch_id": server.touch_to_state(actor_id, vm_id, target_state)} # Pyramid is not designed to allow you to add view configurations programatically. # But in Python all things are possible. Here is a way to set up view configurations in a loop. # This will declare the functions "set_server_to_Boosting", etc... # And bind them to the routes "server_Boosting" and "server_by_id_Boosting" ### Here are the states that can only be set by agents... for state in ["Stopped", "Started", "Prepared", "Pre_Deboosted", "Boosting", "Deboosting", "Starting_Boosted"]: funcname = "set_server_to_" + state globals()[funcname] = lambda request, state=state: _set_server_state(request, state) globals()[funcname] = view_config( request_method="POST", routes=["server_" + state, "server_by_id_" + state], renderer="json", permission="act" )(globals()[funcname]) globals()[funcname].__name__ = funcname globals()[funcname].__qualname__ = funcname ### States that any user can put their server into... for state in ["Starting", "Stopping", "Restarting", "Error"]: funcname = "set_server_to_" + state globals()[funcname] = lambda request, state=state: _set_server_state(request, state) globals()[funcname] = view_config( request_method="POST", routes=["server_" + state, "server_by_id_" + state], renderer="json", permission="use" )(globals()[funcname]) globals()[funcname].__name__ = funcname globals()[funcname].__qualname__ = funcname ### Any user can Boost, but it will cost.