def lookup_template_engine(self, tgl): """Return the template engine data. Provides a convenience method to get the proper engine, content_type, template, and exclude_names for a particular tg_format (which is pulled off of the request headers). """ request = tgl.request response = tgl.response try: render_custom_format = request._render_custom_format[ self.controller] except: render_custom_format = self.render_custom_format if render_custom_format: (content_type, engine, template, exclude_names, render_params) = self.custom_engines[render_custom_format] else: if self.default_engine: content_type = self.default_engine elif self.engines: if response.content_type is not None: # Check for overridden content type from the controller call accept_types = create_accept_header(response.content_type) elif request._response_type and request._response_type in self.engines: # Check for content type detected by request extensions accept_types = create_accept_header(request._response_type) else: accept_types = request.accept best_matches = ( accept_types.acceptable_offers(self.engines_keys) or # If none of the available engines matches with the # available options, just suggest usage of the first engine. ( (self.engines_keys[0], None), )) content_type = best_matches[0][0] else: content_type = 'text/html' # check for overridden templates try: cnt_override_mapping = request._override_mapping[ self.controller] engine, template, exclude_names, render_params = cnt_override_mapping[ content_type.split(";")[0]] except (AttributeError, KeyError): (engine, template, exclude_names, render_params) = self.engines.get(content_type, (None, ) * 4) return content_type, engine, template, exclude_names, render_params
def lookup_template_engine(self, tgl): """Return the template engine data. Provides a convenience method to get the proper engine, content_type, template, and exclude_names for a particular tg_format (which is pulled off of the request headers). """ request = tgl.request response = tgl.response try: render_custom_format = request._render_custom_format[self.controller] except: render_custom_format = self.render_custom_format if render_custom_format: (content_type, engine, template, exclude_names, render_params ) = self.custom_engines[render_custom_format] else: if self.default_engine: content_type = self.default_engine elif self.engines: if response.content_type is not None: # Check for overridden content type from the controller call accept_types = create_accept_header(response.content_type) elif request._response_type and request._response_type in self.engines: # Check for content type detected by request extensions accept_types = create_accept_header(request._response_type) else: accept_types = request.accept best_matches = ( accept_types.acceptable_offers(self.engines_keys) or # If none of the available engines matches with the # available options, just suggest usage of the first engine. ((self.engines_keys[0], None), ) ) content_type = best_matches[0][0] else: content_type = 'text/html' # check for overridden templates try: cnt_override_mapping = request._override_mapping[self.controller] engine, template, exclude_names, render_params = cnt_override_mapping[content_type.split(";")[0]] except (AttributeError, KeyError): (engine, template, exclude_names, render_params ) = self.engines.get(content_type, (None,) * 4) return content_type, engine, template, exclude_names, render_params
def generate_response(self, environ, start_response): if self.content_length is not None: del self.content_length headerlist = list(self.headerlist) accept_value = environ.get('HTTP_ACCEPT', '') accept_header = create_accept_header(header_value=accept_value) acceptable_offers = accept_header.acceptable_offers( offers=['text/html', 'application/json'], ) match = acceptable_offers[0][0] if acceptable_offers else None if match == 'text/html': content_type = 'text/html' body = self.html_body(environ) elif match == 'application/json': content_type = 'application/json' body = self.json_body(environ) else: content_type = 'text/plain' body = self.plain_body(environ) resp = Response(body, status=self.status, headerlist=headerlist, content_type=content_type, ) resp.content_type = content_type return resp(environ, start_response)
def prepare(self, environ): if not self.body: accept_value = environ.get("HTTP_ACCEPT", "") accept = create_accept_header(accept_value) # Attempt to match XML or JSON, if those don't match, we will fall back to defaulting to JSON # since browsers add HTML automatically and it is closer to XML, we 'allow' it only to catch this # explicit case and fallback to JSON manually match = accept.best_match([ CONTENT_TYPE_TEXT_HTML, CONTENT_TYPE_APP_JSON, CONTENT_TYPE_TEXT_XML, CONTENT_TYPE_APP_XML ], default_match=CONTENT_TYPE_APP_JSON) if match == CONTENT_TYPE_TEXT_HTML: match = CONTENT_TYPE_APP_JSON if match == CONTENT_TYPE_APP_JSON: self.content_type = CONTENT_TYPE_APP_JSON # json exception response should not have status 200 if self.status_code == HTTPOk.code: self.status = HTTPInternalServerError.code class JsonPageTemplate(object): def __init__(self, excobj): self.excobj = excobj def substitute(self, code, locator, message): status = self.excobj.status title = getattr(self.excobj, "code", None) data = self.excobj.json_formatter(status=status, body=message, title=title, environ=environ) data["exception"] = { "code": code or "", "locator": locator or "", "message": message or "", } return json.dumps(data) page_template = JsonPageTemplate(self) args = { "code": self.code, "locator": self.locator, "message": self.message } else: self.content_type = CONTENT_TYPE_TEXT_XML page_template = self.page_template args = { "code": self.code, "locator": self.locator, "message": self.message or "", } page = page_template.substitute(**args) if isinstance(page, str): page = page.encode(self.charset if self.charset else "UTF-8") self.app_iter = [page] self.body = page
def generate_response(self, environ, start_response): if self.content_length is not None: del self.content_length headerlist = list(self.headerlist) accept_value = environ.get("HTTP_ACCEPT", "") accept_header = create_accept_header(header_value=accept_value) acceptable_offers = accept_header.acceptable_offers( offers=["text/html", "application/json"] ) match = acceptable_offers[0][0] if acceptable_offers else None if match == "text/html": content_type = "text/html" body = self.html_body(environ) elif match == "application/json": content_type = "application/json" body = self.json_body(environ) else: content_type = "text/plain" body = self.plain_body(environ) resp = Response( body, status=self.status, headerlist=headerlist, content_type=content_type ) resp.content_type = content_type return resp(environ, start_response)
def test_it_sets_response_header_based_on_value_of_accept( self, pyramid_request, testview, accept, expected_header): pyramid_request.accept = create_accept_header(accept) res = version_media_type_header(testview)(None, pyramid_request) assert res.headers["Hypothesis-Media-Type"] == expected_header
def test_it_replaces_context_with_406_if_accept_set_and_invalid( self, pyramid_request, testview): # None of these is valid pyramid_request.accept = create_accept_header( "application/something+json, foo/bar") fake_context = mock.Mock() validate_media_types(testview)(fake_context, pyramid_request) context, _ = testview.call_args[0] assert isinstance(context, HTTPNotAcceptable)
def test_it_does_not_modify_context_if_any_accept_values_ok( self, pyramid_request, testview): # At least one of these is valid pyramid_request.accept = create_accept_header( "application/json, foo/bar") fake_context = mock.Mock() validate_media_types(testview)(fake_context, pyramid_request) context, _ = testview.call_args[0] assert context == fake_context
def prepare(self, environ): if not self.body: accept_value = environ.get("HTTP_ACCEPT", "") accept = create_accept_header(accept_value) # Attempt to match xml or json, if those don't match, we will fall through to defaulting to xml match = accept.best_match( [CONTENT_TYPE_TEXT_XML, CONTENT_TYPE_APP_JSON]) if match == CONTENT_TYPE_APP_JSON: self.content_type = CONTENT_TYPE_APP_JSON # json exception response should not have status 200 if self.status_code == HTTPOk.code: self.status = HTTPInternalServerError.code class JsonPageTemplate(object): def __init__(self, excobj): self.excobj = excobj def substitute(self, code, locator, message): status = self.excobj.status data = self.excobj.json_formatter(status=status, body=message, title=None, environ=environ) data["exception"] = { "code": code or "", "locator": locator or "", "message": message or "", } return json.dumps(data) page_template = JsonPageTemplate(self) else: self.content_type = CONTENT_TYPE_TEXT_XML page_template = self.page_template args = { "code": self.code, "locator": self.locator, "message": self.message or "", } page = page_template.substitute(**args) if isinstance(page, str): page = page.encode(self.charset if self.charset else "UTF-8") self.app_iter = [page] self.body = page
def _get_accept(self): if self._accept is None: self._accept = create_accept_header(None) return self._accept
def _set_accept(self, value): self._accept = create_accept_header(value)
def pyramid_request(self, pyramid_request): # Set an empty accept on the request, imitating what pyramid does # in real life if no Accept header is set on the incoming request pyramid_request.accept = create_accept_header(None) return pyramid_request
def __call__(self, environ, start_response): ''' Implements the WSGI specification for Pecan applications, utilizing ``WebOb``. ''' # create the request and response object req = self.request_cls(environ) resp = self.response_cls() state = RoutingState(req, resp, self) environ['pecan.locals'] = {'request': req, 'response': resp} controller = None # track internal redirects internal_redirect = False # handle the request try: # add context and environment to the request req.context = environ.get('pecan.recursive.context', {}) req.pecan = dict(content_type=None) controller, args, kwargs = self.find_controller(state) self.invoke_controller(controller, args, kwargs, state) except Exception as e: # if this is an HTTP Exception, set it as the response if isinstance(e, exc.HTTPException): # if the client asked for JSON, do our best to provide it accept_header = acceptparse.create_accept_header( getattr(req.accept, 'header_value', '*/*') or '*/*') offers = accept_header.acceptable_offers( ('text/plain', 'text/html', 'application/json')) best_match = offers[0][0] if offers else None state.response = e if best_match == 'application/json': json_body = dumps({ 'code': e.status_int, 'title': e.title, 'description': e.detail }) if isinstance(json_body, six.text_type): e.text = json_body else: e.body = json_body state.response.content_type = best_match environ['pecan.original_exception'] = e # note if this is an internal redirect internal_redirect = isinstance(e, ForwardRequestException) # if this is not an internal redirect, run error hooks on_error_result = None if not internal_redirect: on_error_result = self.handle_hooks( self.determine_hooks(state.controller), 'on_error', state, e) # if the on_error handler returned a Response, use it. if isinstance(on_error_result, WebObResponse): state.response = on_error_result else: if not isinstance(e, exc.HTTPException): raise # if this is an HTTP 405, attempt to specify an Allow header if isinstance(e, exc.HTTPMethodNotAllowed) and controller: allowed_methods = _cfg(controller).get('allowed_methods', []) if allowed_methods: state.response.allow = sorted(allowed_methods) finally: # if this is not an internal redirect, run "after" hooks if not internal_redirect: self.handle_hooks(self.determine_hooks(state.controller), 'after', state) self._handle_empty_response_body(state) # get the response return state.response(environ, start_response)
def find_controller(self, state): ''' The main request handler for Pecan applications. ''' # get a sorted list of hooks, by priority (no controller hooks yet) req = state.request pecan_state = req.pecan # store the routing path for the current application to allow hooks to # modify it pecan_state['routing_path'] = path = req.path_info # handle "on_route" hooks self.handle_hooks(self.hooks, 'on_route', state) # lookup the controller, respecting content-type as requested # by the file extension on the URI pecan_state['extension'] = None # attempt to guess the content type based on the file extension if self.guess_content_type_from_ext \ and not pecan_state['content_type'] \ and '.' in path: _, extension = splitext(path.rstrip('/')) # preface with a letter to ensure compat for 2.5 potential_type = guess_type('x' + extension)[0] if extension and potential_type is not None: path = ''.join(path.rsplit(extension, 1)) pecan_state['extension'] = extension pecan_state['content_type'] = potential_type controller, remainder = self.route(req, self.root, path) cfg = _cfg(controller) if cfg.get('generic_handler'): raise exc.HTTPNotFound # handle generic controllers im_self = None if cfg.get('generic'): im_self = six.get_method_self(controller) handlers = cfg['generic_handlers'] controller = handlers.get(req.method, handlers['DEFAULT']) handle_security(controller, im_self) cfg = _cfg(controller) # add the controller to the state so that hooks can use it state.controller = controller # if unsure ask the controller for the default content type content_types = cfg.get('content_types', {}) if not pecan_state['content_type']: # attempt to find a best match based on accept headers (if they # exist) accept = getattr(req.accept, 'header_value', '*/*') or '*/*' if accept == '*/*' or (accept.startswith('text/html,') and list( content_types.keys()) in self.SIMPLEST_CONTENT_TYPES): pecan_state['content_type'] = cfg.get('content_type', 'text/html') else: best_default = None accept_header = acceptparse.create_accept_header(accept) offers = accept_header.acceptable_offers( list(content_types.keys())) if offers: # If content type matches exactly use matched type best_default = offers[0][0] else: # If content type doesn't match exactly see if something # matches when not using parameters for k in content_types.keys(): if accept.startswith(k): best_default = k break if best_default is None: msg = "Controller '%s' defined does not support " + \ "content_type '%s'. Supported type(s): %s" logger.error( msg % (controller.__name__, pecan_state['content_type'], content_types.keys())) raise exc.HTTPNotAcceptable() pecan_state['content_type'] = best_default elif cfg.get('content_type') is not None and \ pecan_state['content_type'] not in content_types: msg = "Controller '%s' defined does not support content_type " + \ "'%s'. Supported type(s): %s" logger.error(msg % (controller.__name__, pecan_state['content_type'], content_types.keys())) raise exc.HTTPNotFound # fetch any parameters if req.method == 'GET': params = req.GET elif req.content_type in ('application/json', 'application/javascript'): try: if not isinstance(req.json, dict): raise TypeError('%s is not a dict' % req.json) params = NestedMultiDict(req.GET, req.json) except (TypeError, ValueError): params = req.params else: params = req.params # fetch the arguments for the controller args, varargs, kwargs = self.get_args(state, params.mixed(), remainder, cfg['argspec'], im_self) state.arguments = Arguments(args, varargs, kwargs) # handle "before" hooks self.handle_hooks(self.determine_hooks(controller), 'before', state) return controller, args + varargs, kwargs
def _get_accept(self): if self._accept is None: self._accept = create_accept_header(None) return self._accept
def _set_accept(self, value): self._accept = create_accept_header(value)
def prepare(self, environ): if not self.has_body and not self.empty_body: html_comment = '' comment = self.comment or '' accept_value = environ.get('HTTP_ACCEPT', '') accept = create_accept_header(accept_value) # Attempt to match text/html or application/json, if those don't # match, we will fall through to defaulting to text/plain acceptable = accept.acceptable_offers(['text/html', 'application/json']) acceptable = [offer[0] for offer in acceptable] + ['text/plain'] match = acceptable[0] if match == 'text/html': self.content_type = 'text/html' escape = _html_escape page_template = self.html_template_obj br = '<br/>' if comment: html_comment = '<!-- %s -->' % escape(comment) elif match == 'application/json': self.content_type = 'application/json' self.charset = None escape = _no_escape br = '\n' if comment: html_comment = escape(comment) class JsonPageTemplate(object): def __init__(self, excobj): self.excobj = excobj def substitute(self, status, body): jsonbody = self.excobj._json_formatter( status=status, body=body, title=self.excobj.title, environ=environ) return json.dumps(jsonbody) page_template = JsonPageTemplate(self) else: self.content_type = 'text/plain' escape = _no_escape page_template = self.plain_template_obj br = '\n' if comment: html_comment = escape(comment) args = { 'br': br, 'explanation': escape(self.explanation), 'detail': escape(self.detail or ''), 'comment': escape(comment), 'html_comment': html_comment, } body_tmpl = self.body_template_obj if HTTPException.body_template_obj is not body_tmpl: # Custom template; add headers to args for k, v in environ.items(): if (not k.startswith('wsgi.')) and ('.' in k): # omit custom environ variables, stringifying them may # trigger code that should not be executed here; see # https://github.com/Pylons/pyramid/issues/239 continue args[k] = escape(v) for k, v in self.headers.items(): args[k.lower()] = escape(v) body = body_tmpl.substitute(args) page = page_template.substitute(status=self.status, body=body) if isinstance(page, text_type): page = page.encode(self.charset if self.charset else 'UTF-8') self.app_iter = [page] self.body = page
def prepare(self, environ): if not self.has_body and not self.empty_body: html_comment = '' comment = self.comment or '' accept_value = environ.get('HTTP_ACCEPT', '') accept = create_accept_header(accept_value) # Attempt to match text/html or application/json, if those don't # match, we will fall through to defaulting to text/plain acceptable = accept.acceptable_offers( ['text/html', 'application/json']) acceptable = [offer[0] for offer in acceptable] + ['text/plain'] match = acceptable[0] if match == 'text/html': self.content_type = 'text/html' escape = _html_escape page_template = self.html_template_obj br = '<br/>' if comment: html_comment = '<!-- %s -->' % escape(comment) elif match == 'application/json': self.content_type = 'application/json' self.charset = None escape = _no_escape br = '\n' if comment: html_comment = escape(comment) class JsonPageTemplate(object): def __init__(self, excobj): self.excobj = excobj def substitute(self, status, body): jsonbody = self.excobj._json_formatter( status=status, body=body, title=self.excobj.title, environ=environ, ) return json.dumps(jsonbody) page_template = JsonPageTemplate(self) else: self.content_type = 'text/plain' escape = _no_escape page_template = self.plain_template_obj br = '\n' if comment: html_comment = escape(comment) args = { 'br': br, 'explanation': escape(self.explanation), 'detail': escape(self.detail or ''), 'comment': escape(comment), 'html_comment': html_comment, } body_tmpl = self.body_template_obj if HTTPException.body_template_obj is not body_tmpl: # Custom template; add headers to args for k, v in environ.items(): if (not k.startswith('wsgi.')) and ('.' in k): # omit custom environ variables, stringifying them may # trigger code that should not be executed here; see # https://github.com/Pylons/pyramid/issues/239 continue args[k] = escape(v) for k, v in self.headers.items(): args[k.lower()] = escape(v) body = body_tmpl.substitute(args) page = page_template.substitute(status=self.status, body=body) if isinstance(page, str): page = page.encode(self.charset if self.charset else 'UTF-8') self.app_iter = [page] self.body = page