def process_preflight(self, request): """ Preflight request support for apollo-client https://www.w3.org/TR/cors/#resource-preflight-requests """ origin = request.headers.get("Origin", "") method = request.headers.get("Access-Control-Request-Method", "").upper() if method and method in self.methods: return HTTPResponse( status=200, headers={ "Access-Control-Allow-Origin": origin, "Access-Control-Allow-Methods": ", ".join(self.methods), "Access-Control-Max-Age": str(self.max_age), }, ) else: return HTTPResponse(status=400)
async def oauth_start(req: Request): state = state_store.issue() url = authorization_url_generator.generate(state) return HTTPResponse( status=200, body=f'<a href="{url}">' \ f'<img alt=""Add to Slack"" height="40" width="139" src="https://platform.slack-edge.com/img/add_to_slack.png" srcset="https://platform.slack-edge.com/img/add_to_slack.png 1x, https://platform.slack-edge.com/img/[email protected] 2x" /></a>' )
def response(self, id, error): id = id if id else uuid.uuid1().__str__() base64_data, code = self.code() session[id] = code body = self.body.format(base64_data=base64_data, error=error) response = HTTPResponse(body, content_type="text/html; charset=utf-8") response.cookies["uuid"] = id return response
async def create_resource(request: Request) -> HTTPResponse: # If you want to be really fancy, here, you could generate the `route` name # from your API docs, or from your function name, or something like that. await verify_auth('create-resource', request.headers) # business logic goes here return HTTPResponse('successfully created resource', status=200)
async def process_file_async(request: Request): file_path = request.body.decode('utf8') if not file_path: return HTTPResponse(status=400) with provide_throttling() as throttling: await throttling features_path = await extract_features_async(file_path) if not features_path: return HTTPResponse(status=500) results = await run_model_async(features_path) return json({ 'features_path': features_path, 'data': list(r.to_tuple() for r in results) })
async def json(request): await asyncio.sleep(10) return HTTPResponse( data, headers=None, status=200, content_type="application/json", )
async def get(self, request, doc_id): doc = await self.mongo.get_doc(doc_id=doc_id) if doc: return HTTPResponse(body=self.mongo.docs_to_json(doc), content_type="application/json") else: raise sanic.exceptions.NotFound( message='Cannot find document with' ' id:{0}'.format(doc_id))
def jobs_results_id_delete(request: Request, job_id: str, result_id: str) -> HTTPResponse: try: url_root = _get_url_root(request) JobDeleteService(url_root, job_id).delete_partial(result_id) return HTTPResponse({}) except Exception as e: log.exception(e) message = 'Error while deleting : job_id = {}, result_id = {}'.format(job_id, result_id) raise ServerError(message, status_code=500)
async def provide_to_model(request, model_type, model_name): print(request.method) if request.method == 'GET': response = json(get_model_data(model_type, model_name, request.args)) response.content_type = 'application/json; charset=utf-8;' elif request.method == 'POST': update_model_data(model_type, model_name, loads(request.json)) response = HTTPResponse(status=200, body='OK') return response
def wrapped(*args, **kwargs): if asyncio.iscoroutinefunction(func): coro = func else: coro = asyncio.coroutine(func) context = yield from coro(*args, **kwargs) # wrapped function return HTTPResponse # instead of dict-like object if isinstance(context, HTTPResponse): return context # wrapped function is class method # and got `self` as first argument if isinstance(args[0], HTTPMethodView): request = args[1] else: request = args[0] if context is None: context = {} env = getattr(request.app, "jinja_env", None) if not env: raise ServerError( "Template engine has not been initialized yet.", status_code=500) try: template = env.get_template(template_name) except TemplateNotFound as e: raise ServerError( "Template '{}' not found".format(template_name), status_code=500) if not isinstance(context, Mapping): raise ServerError( "context should be mapping, not {}".format( type(context)), status_code=500, ) # if request.get(REQUEST_CONTEXT_KEY): # context = dict(request[REQUEST_CONTEXT_KEY], **context) update_request_context(request, context) if request.app.enable_async: text = yield from template.render_async(context) else: text = template.render(context) content_type = "text/html; charset={}".format(encoding) return HTTPResponse( text, status=status, headers=headers, content_type=content_type, )
async def get(self, request): import pdb pdb.set_trace() name = request.raw_args.get('name', '') persons = Person.select() if name: persons = persons.select().where(Person.name == name) persons_list = [model_to_dict(p) for p in persons] return HTTPResponse(sjson.dumps(persons_list, default=str))
async def image_from_id(request, id): path = await conn.fetchval("select path from pictures where id = $1", id) async with aiofiles.open(path, 'rb') as f: data = await f.read() return HTTPResponse(status=200, headers=None, content_type="image/jpeg", body_bytes=data)
def create_product(request: Request) -> HTTPResponse: product_storage = request.app.services.product_storage product_data = request.json try: product_storage.create_product(product_data) except Exception: raise Exception('Failed to create product') return HTTPResponse(status=204)
async def image_from_id(request): path = request.args['path'][0] async with aiofiles.open(path, 'rb') as f: data = await f.read() return HTTPResponse(status=200, headers=None, content_type="image/jpeg", body_bytes=data)
async def get_idioms(request): if 'query' not in request.args: return HTTPResponse(status=400, body='invalid query') query = ''.join(request.args['query']) if len(query) > 15: return HTTPResponse(status=400, body='query too long') try: res = await scraper.scrape_idioms(query) return json([{ 'idiom': r[0], 'score': r[1] } for r in res], ensure_ascii=False) except Exception as e: logger.exception(e) return HTTPResponse(status=503)
async def get_initialize(request): db_initialize() global VOTE_CACHE, VOTE_COUNT_CACHE, VOTE_KEYWORD_CACHE, HTML_CACHE, VOTE_COUNTER VOTE_CACHE = defaultdict(int) VOTE_COUNT_CACHE = defaultdict(int) VOTE_KEYWORD_CACHE = defaultdict(Counter) HTML_CACHE = {} VOTE_COUNTER = 0 return HTTPResponse()
async def post(self, request): # import pdb # pdb.set_trace() data = request.form post_data = {'name': data.get('name', ''), 'birthday': data.get('birthday', '')} persons = Person.create(**post_data) # persons = Person.insert_many(**data) # persons = [model_to_dict(i) for i in persons] # return json(model_to_dict(persons)) return HTTPResponse(sjson.dumps(persons, default=str))
async def status(request: Request) -> HTTPResponse: redis = request.app.redis with timeout(1): result = await redis.ping() if result != b'PONG': return HTTPResponse("Backend is not Redis", status=500) return text("OK", status=200)
def test_response_body_bytes_deprecated(app): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") HTTPResponse(body_bytes=b"bytes") assert len(w) == 1 assert issubclass(w[0].category, DeprecationWarning) assert ("Parameter `body_bytes` is deprecated, use `body` instead" in str(w[0].message))
def redirect(to, headers=None, status=302, content_type="text/html; charset=utf-8"): headers = headers or {} safe_to = to headers["Location"] = safe_to return HTTPResponse(status=status, headers=headers, content_type=content_type)
async def configurate(request): try: configuration = request.json logger.debug('configuration: %s', configuration) except InvalidUsage: logger.error('invalid configuration') return HTTPResponse(status=400) if configuration: try: await sc.update_servers(configuration) logger.debug('configuration succedded') return HTTPResponse() except Exception as e: logger.error('failed to configurate: %s', e) return HTTPResponse(status=500) else: logger.error('empty configuration') return HTTPResponse(status=400)
def process_preflight(self, request): """ Preflight request support for apollo-client https://www.w3.org/TR/cors/#resource-preflight-requests """ origin = request.headers.get('Origin', '') method = request.headers.get('Access-Control-Request-Method', '').upper() if method and method in self.methods: return HTTPResponse(status=200, headers={ 'Access-Control-Allow-Origin': origin, 'Access-Control-Allow-Methods': ', '.join(self.methods), 'Access-Control-Max-Age': str(self.max_age), }) else: return HTTPResponse(status=400, )
def json(body: Dict[str, Any], status: int = 200, headers: Optional[Any] = None, content_type: str = "application/json", **kwargs: Any) -> HTTPResponse: return HTTPResponse( dumps(body, separators=(",", ":"), cls=APIJSONEncoder, **kwargs), headers=headers, status=status, content_type=content_type, )
def ParameterException(request): return HTTPResponse( json_dumps({ "error_code": 1000, "message": "invalid parameter", "request": request.method + " " + request.path }), headers=None, status=400, content_type="application/json", )
def run(self): if self.request.method == 'GET': return self.get() elif self.request.method == 'POST': return self.post() elif self.request.method == 'PATCH': return self.patch() elif self.request.method == 'DELETE': return self.delete() return HTTPResponse(status=405)
async def distrib(request): potatoes = dbServer.get_all_potatoes() pie_chart = pygal.Pie() for potato in potatoes: pie_chart.add(potato['type'], int(potato['count'])) return HTTPResponse( body_bytes=pie_chart.render(), status=200, headers=None, content_type="image/svg+xml")
def AuthFailed(request): return HTTPResponse( json_dumps({ "error_code": 1005, "message": "authorization failed", "request": request.method + " " + request.path }), headers=None, status=401, #禁止访问 content_type="application/json", )
def AuthFailed2(request, error_code, message): return HTTPResponse( json_dumps({ "error_code": error_code, "message": message, "request": request.method + " " + request.path }), headers=None, status=401, content_type="application/json", )
def output_json_fast_orjson(request, data, code, headers=None): current_app = request.app if current_app.debug: return output_json_pretty(request, data, code, headers=headers) settings = current_app.config.get('RESTPLUS_JSON', {}) dumped = fast_dumps( data, option=orjson_opts, default=orjson_default, ** settings) + b"\n" if use_body_bytes: resp = HTTPResponse(None, code, headers, content_type='application/json', body_bytes=dumped) else: resp = HTTPResponse(dumped, code, headers, content_type='application/json') return resp
async def inner(*args, **kwargs): result = func(*args, **kwargs) if result is None or isinstance(result, HTTPResponse): return result if isawaitable(result): result = await result return HTTPResponse(json.dumps(result), content_type="application/json", status=200)