async def process(self): request = self.request try: callback = request.query_args.get("c", None) except Exception: callback = request.args.get("c", None) if callback is None: await self.session._remote_closed() raise exceptions.ServerError('"callback" parameter required') elif not self.check_callback.match(callback): await self.session._remote_closed() raise exceptions.ServerError('invalid "callback" parameter') headers = ( ('Content-Type', "text/html; charset=UTF-8"), ('Cache-Control', CACHE_CONTROL), ('Connection', "close"), ) headers += session_cookie(request) headers += cors_headers(request.headers) async def stream(_response): nonlocal self self.response = _response await _response.write(b"".join( (PRELUDE1, callback.encode("utf-8"), PRELUDE2, b" " * 1024))) # handle session await self.handle_session() # open sequence (sockjs protocol) return StreamingHTTPResponse(stream, headers=headers)
async def serve(request): try: if (config["allow_download_dataset"]): return await response.file(config["dataset_file"]) else: raise exceptions.ServerError("Option not enabled", status_code=401) except: debug(("Unexpected error:", sys.exc_info()[0])) raise exceptions.ServerError("Bad key", status_code=401)
def parse_coordinates(args): if not args.get("xy"): raise exceptions.ServerError("XY parameter is requried.", status_code=500) elements = args.get("xy").split(",") try: elements = [float(elem) for elem in elements] except ValueError: raise exceptions.ServerError( "Unable to handle xy. Verify that xy is a comma-separated string of numbers.", status_code=500) return [tuple(elements[x:x + 2]) for x in range(0, len(elements), 2)]
async def chat(request): try: if(request.json["statement"] and request.json["response"] and request.json['userid']): persona = config["personas"].index(request.json["persona"]) if(request.json["bad_response"] == ""): pass if (badwords.hasBadWords(request.json["statement"])==False): chatbots[persona].train(request.json["statement"], request.json["response"], request.json.get("bad_response", "")) nsfw="" if(badwords.hasBadWords(request.json["statement"]) or badwords.hasBadWords(request.json["response"])) : nsfw="nsfw" if(request.json["bad_response"] == False): with open(config.get("dataset_file", "./chat_dataset"+nsfw+".csv"), 'a') as f: # Concatination is faster than join csv = (request.json.get('statement')+";" + request.json.get('response')+";" + request.json.get('persona')+";" + request.json.get('userid')) f.write(csv+'\n') return response.json({"status": "ok"}) except: debug(("Unexpected error:", sys.exc_info()[0])) raise exceptions.ServerError("Bad Request", status_code=401)
def make_response(self, request, data, *args, **kwargs): """ Looks up the representation transformer for the requested media type, invoking the transformer to create a response object. This defaults to default_mediatype if no transformer is found for the requested mediatype. If default_mediatype is None, a 406 Not Acceptable response will be sent as per RFC 2616 section 14.1 :param data: Python object containing response data to be transformed """ default_mediatype = kwargs.pop('fallback_mediatype', None) or self.default_mediatype mediatype = best_match_accept_mimetype( request, self.representations, default=default_mediatype, ) if mediatype is None: raise exceptions.SanicException("Not Acceptable", 406) if mediatype in self.representations: resp = self.representations[mediatype](request, data, *args, **kwargs) resp.headers['Content-Type'] = mediatype return resp elif mediatype == 'text/plain': resp = text(str(data), *args, **kwargs) resp.headers['Content-Type'] = 'text/plain' return resp else: raise exceptions.ServerError(None)
async def add(request): try: if(request.json["text"] and request.json["emotions"] and config.get("add_dataset",True)): with open(config.get("dataset_file","./emotion_dataset.csv"), 'a') as f: # Concatination is faster than join csv = (request.json.get('text')+";" + request.json["emotions"].get('anger', "0")+";" + request.json["emotions"].get('boredom', "0")+";" + request.json["emotions"].get('empty', "0")+";" + request.json["emotions"].get('enthusiasm', "0")+";" + request.json["emotions"].get('fear', "0")+";" + request.json["emotions"].get('happiness', "0")+";" + request.json["emotions"].get('hate', "0")+";" + request.json["emotions"].get('love', "0")+";" + request.json["emotions"].get('neutral', "0")+";" + request.json["emotions"].get('anger', "0")+";" + request.json["emotions"].get('relief', "0")+";" + request.json["emotions"].get('sadness', "0")+";" + request.json["emotions"].get('worry', "0")) f.write(csv+'\n') return response.text("ok") except: debug(("Unexpected error:", sys.exc_info()[0])) raise exceptions.ServerError( "Bad Request: 'text' or 'emotions' doesnt exist in json", status_code=401)
async def test2(request): try: if (request.args["text"]): return response.text("Valid request") except: debug(("Unexpected error:", sys.exc_info()[0])) raise exceptions.ServerError("Bad Request", status_code=401)
async def fetch_link(request, username): """ Fetch link from the given username :param request: The thing that sanic give us, but seems it is useless in this case. :param username: The requested username. :return: Redirection if the profile page's link has been found. """ logger.debug(request) # Stop IDEA from blaming me about unused variable if username in CACHE.keys(): logger.info('Cache hit: [ %s: %s ]' % (username, CACHE[username])) return response.redirect(CACHE[username]) name = username.split('@') if len(name) != 2: raise exceptions.InvalidUsage('Invalid username', status_code=400) host_meta = await fetch('https://' + name[1] + '/.well-known/host-meta') try: host_links = host_meta['XRD']['Link'] except TypeError: raise exceptions.InvalidUsage('Unsupported platform', status_code=400) # Get Webfinger's URL webfinger = '' if type(host_links) == list: for link in host_links: if is_webfinger(link): webfinger = link['@template'] break elif type(host_links) == OrderedDict: if is_webfinger(host_links): webfinger = host_links['@template'] else: raise exceptions.InvalidUsage('Unsupported platform', status_code=400) # Request Webfinger for user's meta user_meta = await fetch( webfinger.replace('{uri}', 'acct%3A' + username.replace('@', '%40'))) try: user_link = '' if 'aliases' in user_meta.keys(): # If the server provides aliases user_link = user_meta['aliases'][0] elif 'links' in user_meta.keys(): # Otherwise, read `links` for link in user_meta['links']: if link['rel'] == 'self' or link[ 'rel'] == 'http://webfinger.net/rel/profile-page': user_link = link['href'] else: raise exceptions.InvalidUsage('Unsupported platform', status_code=400) if user_link: logger.info('Adding to cache: [ %s: %s ], redirecting...' % (username, user_link)) CACHE[username] = user_link return response.redirect(user_link) else: raise exceptions.ServerError( 'I don\'t really know what\'s going on...', status_code=500) except Exception: raise exceptions.InvalidUsage( 'Unknown error, probably the user doesn\'t exist.', status_code=500)
async def classify(request): try: if(request.args["text"]): return response.json({"classification": classify_emotion(request.args["text"])}) except: debug(("Unexpected error:", sys.exc_info()[0])) raise exceptions.ServerError( "Bad Request,missing 'text' paramerter", status_code=401)
def parse_flow(args): if not args.get("flow") or args.get("flow") == "origin": return "origin" elif args.get("flow") == "destination": return "destination" else: raise exceptions.ServerError( "Unsupported flow specified. Must be either origin (default) or destination.", status_code=500)
def get_query_geom(coords): if len(coords) == 1: return Point(coords) elif len(coords) > 2: return asPolygon(coords) else: raise exceptions.ServerError( "Insufficient xy coordinates provided. A LinearRing must have at least 3 coordinate tuples.", status_code=500)
async def chat(request): try: if(request.json["statement"] and request.json['userid']): reply = chatbots[config["personas"].index(request.json["persona"])].reply( request.json["statement"]) return response.json({"response": reply}) except: debug(("Unexpected error:", sys.exc_info()[0])) raise exceptions.ServerError( "Bad Request missing json 'statement' or 'userid'", status_code=401)
def parse_mode(args): if not args.get("mode") or args.get("mode") == "all": return "total" elif args.get("mode") == "scooter": return "scooter" elif args.get("mode") == "bicycle": return "bicycle" else: raise exceptions.ServerError( "Unsupported mode specified. Must be either scooter, bicycle, or all (default).", status_code=500)
async def process(self): # start websocket connection try: p = self.request.transport.get_protocol() except: raise exceptions.ServerError( "Cannot get http protocol from transport") if isinstance(p, WebSocketProtocol): wsp = p else: loop = asyncio.get_event_loop() app = self.request.app wsp = WebSocketProtocol(loop=loop, app=app, request_handler=app.handle_request, error_handler=app.error_handler) wsp.transport = self.request.transport self.request.transport.set_protocol(wsp) ws = self.ws = await wsp.websocket_handshake(self.request) # session was interrupted if self.session.interrupted: await self.ws.send_str(close_frame(1002, "Connection interrupted")) elif self.session.state == STATE_CLOSED: await self.ws.send_str(close_frame(3000, "Go away!")) else: try: await self.manager.acquire(self.session) except Exception: # should use specific exception await self.ws.send_str(close_frame(3000, "Go away!")) await ws.close() return ws server = ensure_future(self.tx_loop(ws, self.session)) client = ensure_future(self.rx_loop(ws, self.session)) try: await asyncio.wait((server, client), return_when=asyncio.FIRST_COMPLETED) except asyncio.CancelledError: raise except Exception as exc: await self.session._remote_close(exc) finally: await self.manager.release(self.session) if not server.done(): server.cancel() if not client.done(): client.cancel() return ws
async def process(self): request = self.request allowed_methods = ('GET', 'POST', 'OPTIONS') if request.method not in allowed_methods: # TODO: This was previously exceptions.forbidden. Which is right? raise exceptions.MethodNotSupported("Method is not allowed", request.method, allowed_methods) if self.request.method == 'OPTIONS': headers = ( ('Access-Control-Allow-Methods', "OPTIONS, POST"), ('Content-Type', "application/javascript; charset=UTF-8"), ) headers += session_cookie(request) headers += cors_headers(request.headers) headers += cache_headers() return HTTPResponse(None, status=204, headers=headers) data = await request.stream.read() if not data: raise exceptions.ServerError("Payload expected.") try: messages = loads(data.decode(ENCODING)) except Exception: raise exceptions.ServerError(text="Broken JSON encoding.") await self.session._remote_messages(messages) headers = ( ('Content-Type', "text/plain; charset=UTF-8"), ('Cache-Control', CACHE_CONTROL), ) headers += session_cookie(request) headers += cors_headers(request.headers) return HTTPResponse(status=204, headers=headers)
def parse_mode(args): if not args.get("mode"): return "all" elif args.get("mode").lower() == "all": return "all" elif args.get("mode").lower() == "scooter": return "scooter" elif args.get("mode").lower() == "bicycle": return "bicycle" else: raise exceptions.ServerError( "Unsupported mode specified. Must be either `scooter`, `bicycle`, or `all` (default).", status_code=500, )
def get_flow_keys(flow): """ Bit of harcoding to map the flow to the corresponding dataset property """ if flow == "origin": flow_key_init = "cell_id_start" flow_key_end = "cell_id_end" elif flow == "destination": flow_key_init = "cell_id_end" flow_key_end = "cell_id_start" else: # this should never happen because we validate the flow param when parsing # the request raise exceptions.ServerError( "Unsupported flow specified. Must be either `origin` (default) or `destination`.", status_code=500, ) return [flow_key_init, flow_key_end]
def to_local_string(timestamp): if not timestamp: return None try: timestamp = int(float(timestamp)) / 1000 except ValueError: raise exceptions.ServerError( f"{date_param} must be a number representing Unix time in milliseconds.", status_code=500, ) # for god knows why utcfromtimestamp returns a naive timestamp. # so we have to append `.replace(tzinfo=pytz.utc)` to make it tz aware dt = datetime.utcfromtimestamp(timestamp).replace(tzinfo=pytz.utc) # and now we can represent the time in # we lop off the tz info from the timestamp because we're going # to pass socrata a "local" naive timestamp (YYYY-MM-DDTHH:MM:SS) return local.isoformat()[0:19]
async def handler(self, request, server, sid, tid): if tid not in self.handlers or tid in self.disable_transports: raise exceptions.NotFound("SockJS transport handler not found.") create, transport = self.handlers[tid] # session manager = self.manager if not manager.started: manager.start() if not sid or "." in sid or "." in server: raise exceptions.NotFound("SockJS bad route") try: session = manager.get(sid, create, request=request) except KeyError: return response.HTTPResponse(None, status=404, headers=session_cookie(request)) t = transport(manager, session, request) try: return await t.process() except asyncio.CancelledError: raise except exceptions.SanicException as exc: msg = "Server Exception in Transport handler: %s" % str(exc) log.exception(msg) raise except Exception: msg = "Exception in transport: %s" % tid log.exception(msg) if manager.is_acquired(session): await manager.release(session) raise exceptions.ServerError(msg)
async def process(self): session = self.session request = self.request meth = request.method if request.method == 'GET': try: callback = self.callback = request.query_args.get("c") except Exception: callback = self.callback = request.args.get("c", None) if not callback: await self.session._remote_closed() raise exceptions.ServerError('"callback" parameter required') elif not self.check_callback.match(callback): await self.session._remote_closed() raise exceptions.ServerError('invalid "callback" parameter') headers = ( ('Content-Type', "application/javascript; charset=UTF-8"), ('Cache-Control', CACHE_CONTROL), ) headers += session_cookie(request) headers += cors_headers(request.headers) async def stream(_response): nonlocal self self.response = _response # handle session await self.handle_session() # open sequence (sockjs protocol) return StreamingHTTPResponse(stream, headers=headers) elif request.method == 'POST': data = await request.stream.read() ctype = request.content_type.lower() if ctype == "application/x-www-form-urlencoded": if not data.startswith(b"d="): raise exceptions.ServerError("Payload expected.") data = unquote_plus(data[2:].decode(ENCODING)) else: data = data.decode(ENCODING) if not data: raise exceptions.ServerError("Payload expected.") try: messages = loads(data) except Exception: raise exceptions.ServerError("Broken JSON encoding.") await session._remote_messages(messages) headers = ( ('Content-Type', "text/html;charset=UTF-8"), ('Cache-Control', CACHE_CONTROL), ) headers += session_cookie(request) return HTTPResponse(None, body_bytes=b"ok", headers=headers) else: raise exceptions.MethodNotSupported( "No support for such method: %s" % meth, meth, ('GET', 'POST'))
async def function_execute(request): """ :param request: functions: [{model: "model", function: "function"}] :return: """ functions = request.json.get('functions', {}) origin_data = request.json.get('origin_data', {}) db = await Mongo().db() if not (functions and origin_data): raise exceptions.ServerError("请检查必要参数的传入!") # begin step = 0 task_uuid = str(uuid.uuid4()) for f in functions: complete_model = f.get('model') function = f.get('function') try: index = complete_model.rfind('.') module, model = complete_model[:index], complete_model[index + 1:] Class = getattr(__import__(module, fromlist=[module]), model) if step == 0: data = origin_data await db.record.insert_one({ "task_uuid": task_uuid, "step": 0, "function": '.'.join([complete_model, function]), "record": origin_data }) else: rec = await db.record.find({ 'task_uuid': task_uuid, 'step': step }).to_list(length=1) # data = await rec.to_list(length=1) data = rec[0].get('record') step += 1 record = await getattr(Class(), function)(data) # mongodb create val = { "task_uuid": task_uuid, "step": step, "function": '.'.join([complete_model, function]), "record": record } await db.record.insert_one(val) except AttributeError: raise exceptions.ServerError("请检查第%s步的方法" % step) except Exception as e: logger.error(e) raise exceptions.ServerError(e) return json(record)