def get(self, filename):
index = RequestHandler.get_argument(self, name='index',
default='papers')
# allow query to be passed to body:
body = RequestHandler.get_argument(self, name='body',
default={'query': {'match_all': {}}})
response = es.search(index=index, body=body)
hits = response['hits']['hits']
self.write(json.dumps(hits))
def get(self, filename):
index = RequestHandler.get_argument(self,
name='index',
default='papers')
# allow query to be passed to body:
body = RequestHandler.get_argument(
self, name='body', default={'query': {
'match_all': {}
}})
response = es.search(index=index, body=body)
hits = response['hits']['hits']
self.write(json.dumps(hits))
async def trending(req: RequestHandler, start_url: str):
lang = req.get_argument("lang", None)
since = req.get_argument("since", None)
url = start_url
if lang is not None:
lang = lang.replace('-shuo', '%23')
url += lang
params = None
if since is not None:
params = {'since': since}
result = await get_trending(url=url, params=params)
if result['count'] > 0:
req.set_status(201)
else:
req.set_status(404)
req.finish(result)
def process_request(self, handler: RequestHandler):
headers = handler.request.headers
token = headers.get('Suri-Token', None)
if not token:
token = headers.get('SURI-TOKEN', None)
if not token:
token = handler.get_argument('tk', None, True)
handler.is_web = True
# logger.info("Middle CheckLogin in token:{}".format(token))
if "undefined" == token:
token = None
if "login" != token and token:
handler.user_payload = get_payload_from_token(token)
handler.token = token
if handler.user_payload:
if 'ext' in handler.user_payload:
handler.user_type = handler.user_payload['ext'].get(
't', USER_TYPE['SINGLE'])
if 'id' in handler.user_payload:
fuzzy_user_id = handler.user_payload['id']
handler.user_id = decrypt_user_id(fuzzy_user_id)
handler.user_payload['user_id'] = handler.user_id
if '_p' in handler.user_payload:
fuzzy_pan_id = handler.user_payload['_p']
handler.default_pan_id = decrypt_user_id(fuzzy_pan_id)
if 'au' in handler.user_payload:
au = handler.user_payload['au']
handler.ref_id = au['rfid']
pass
def get(self, filename):
f = open('json/nodes.json', 'r')
# self.write(f.read())
json_obj = json.loads(f.read())
# unpack parameters
num_requested = int(RequestHandler.get_argument(self, name='num', default=10))
first_entry_requested = int(RequestHandler.get_argument(self, name='start', default=0))
last_entry_requested = first_entry_requested + num_requested;
json_to_return = []
for i in range(first_entry_requested, last_entry_requested):
print("i+1: {}".format(i+1))
print(type(json_obj))
try:
json_to_return.append(json_obj[u'data'][i])
except IndexError:
break;
self.write(json.dumps(json_to_return))
def get_argument(self, name, default=None, strip=True):
def_ = {}
argument = RequestHandler.get_argument(self, name, default=def_)
if argument is def_:
# try to find it in json body
data = self.get_json()
if data:
argument = data.get(name, def_)
if argument is def_:
argument = default
return argument
def get(self, filename):
f = open('json/nodes.json', 'r')
# self.write(f.read())
json_obj = json.loads(f.read())
# unpack parameters
num_requested = int(
RequestHandler.get_argument(self, name='num', default=10))
first_entry_requested = int(
RequestHandler.get_argument(self, name='start', default=0))
last_entry_requested = first_entry_requested + num_requested
json_to_return = []
for i in range(first_entry_requested, last_entry_requested):
print("i+1: {}".format(i + 1))
print(type(json_obj))
try:
json_to_return.append(json_obj[u'data'][i])
except IndexError:
break
self.write(json.dumps(json_to_return))
def get_argument(self, name, default=_ARG_DEFAULT_MANGO, is_json=False):
# pylint: disable=protected-access
# Allow access to `RequestHandler` default argument.
if not is_json:
if default is self._ARG_DEFAULT_MANGO:
default = RequestHandler._ARG_DEFAULT
return RequestHandler.get_argument(self, name, default)
self.get_json_data()
if name not in self.json_data:
if default is self._ARG_DEFAULT_MANGO:
raise HTTPError(400, "Missing argument %s" % name)
return default
return self.json_data[name]
def get(self):
article = RequestHandler.get_argument(self, name='article')
print('-----------------enter get...')
article = translator.translate(article, src='auto', dest='en').text.lower().replace('.', ' .').replace(',', ' ,')
try:
print('---article_cn in get:', article)
print('---article_en:', article)
except Exception as e:
print(str(e))
pass
print("Loading dictionary...")
word_dict, reversed_dict, article_max_len, summary_max_len = build_dict("valid", args.toy)
valid_x, valid_y = build_deploy(article, word_dict, article_max_len, summary_max_len)
valid_x_len = list(map(lambda x: len([y for y in x if y != 0]), valid_x))
batches = batch_iter(valid_x, valid_y, args.batch_size, 1)
print("Start auto summarization...")
for batch_x, batch_y in batches:
batch_x_len = list(map(lambda x: len([y for y in x if y != 0]), batch_x))
valid_feed_dict = {
model.batch_size: len(batch_x),
model.X: batch_x,
model.X_len: batch_x_len,
}
t0 = time.time()
prediction = sess.run(model.prediction, feed_dict=valid_feed_dict)
prediction_output = list(map(lambda x: [reversed_dict[y] for y in x], prediction[:, 0, :]))
print('inference time:', str(time.time() - t0) + 's')
line = prediction_output[0]
summary = list()
for word in line:
if word == "</s>":
break
if word not in summary:
summary.append(word)
title_pred = " ".join(summary)
print('title_pred:', title_pred)
title_cn = translator.translate(title_pred, src='auto', dest='zh-cn').text
# print('title_cn:', title_cn)
self.write(str(title_cn) + '\n')
def get_argument(self, name, default=[], strip=True):
_argument = RequestHandler.get_argument(self,
name,
default,
strip=strip)
#The returned value of RequestHandler.get_argument is always unicode if no default given.
#But if default is given,return could be anything.
#Only filter unicode here.
if 1 == 2 and isinstance(_argument, type(u"1")):
#replac "1 == 1" with "switch" here
if arguementFiltered == "":
arguementFiltered = default
if arguementFiltered != _argument:
logging.warning(
"Sql injection deteceted. Attack url:[{0}] Data:[ {1} : {2} ]"
.format(self.request.uri, name, _argument))
return arguementFiltered
return _argument
def param(self, name, default=RequestHandler._ARG_DEFAULT,
strip=True, type=identity, ensure=identity):
'''
Returns the value of the argument with the given `name`, converting it to
`type` if specified.
If `ensure` is specified it will be called after the type conversion.
The contact for `type` is that it have to take one argument and raise
`ValueError` on bad input.
The contact for `ensure` is that it have to take one argument and raise
`TypeError` on bad input.
'''
try:
value = type(RequestHandler.get_argument(self, name, default, strip))
value = ensure(value)
except (ValueError, TypeError), message:
self.error(BadRequest(message))
def run_pre_cell(self, config, req: RequestHandler) -> str:
variables = config['variables']
if req.request.method == 'POST':
json_body = json.loads(req.request.body)
else:
json_body = {}
code = ''
for v in variables.keys():
var_type = variables[v]
if var_type == 'query':
arg_string = req.get_argument(v, None)
if arg_string is not None:
code += f'{v} = {arg_string}\n'
if var_type == 'post' and req.request.method == 'POST':
arg_string = json_body.get(v, None)
if arg_string is not None:
code += f'{v} = {arg_string}\n'
return code
def get_argument(self, name, default=None, strip=True):
return RequestHandler.get_argument(self, name, default, strip)
