def score():
if request.headers['Content-Type'] != 'application/json':
resp = Response('Unssuported content type, expected application/json', status=500);
return resp
if (not request.json.has_key('text')):
resp = Response('Bad request: missing "text" field in JSON body', status=500);
return resp
if (not request.json.has_key('entities')):
resp = Response('Bad request: missing "entities" field in JSON body', status=500);
return resp
text = request.json['text']
entities = request.json['entities']
try:
scorerResult = scorer.evaluate_score(text, entities)
resp = jsonify(scorer_result_to_response_format(scorerResult))
resp.status_code = 200
return resp
except Exception as e:
resp = Response("Internal Server Error: %s"%e, status = 500)
return resp
python类headers()的实例源码
def update_model():
if request.headers['Content-Type'] != 'application/json':
resp = Response('Unssuported content type, expected application/json', status=500);
return resp
if (not request.json.has_key('path')):
resp = Response('Bad request: missing "path" field in JSON body', status=500);
return resp
path = request.json['path']
try:
scorer.load_model_from_url(path)
resp = Response("", status=200);
return resp
except Exception as e:
resp = Response("Internal Server Error: %s"%e, status = 500)
return resp
def contains_payment(self, price, request_headers, **kwargs):
"""Validate the payment information received in the request headers.
Args:
price (int): The price the user must pay for the resource.
request_headers (dict): Headers sent by client with their request.
keyword args: Any other headers needed to verify payment.
Returns:
(bool): True if payment is valid,
False if no payment attached (402 initiation).
Raises:
BadRequest: If request is malformed.
"""
for method in self.allowed_methods:
if method.should_redeem(request_headers):
try:
return method.redeem_payment(price, request_headers, **kwargs)
except PaymentError as e:
raise BadRequest(str(e))
except Exception as e:
raise BadRequest(repr(e))
return False
def view_sql(backend):
"""View data from database.
By default, thise route runs in autocommit false.
Args:
sql: Valid sql for your backend
sql_params: Optional jinja2 params
Returns:
json
"""
key = request.headers['x-api-key']
args = request.args
sql = args['sql']
sql_params = args.get('sql_params', '{}')
autocommit = False
client = _connect(backend, key, autocommit)
rendered_sql = _format_sql(sql, sql_params)
results = _sql_cmd(client, rendered_sql)
return jsonify([(dict(row.items())) for row in results])
def execute_sql(backend):
"""Modify data from the database.
Args:
sql: valid sql for your backend
sql_params: Optional jinja2 params
Returns:
json
"""
key = request.headers['x-api-key']
args = request.json
sql = args['sql']
sql_params = args.get('sql_params', '{}')
autocommit = args.get('autocommit', False)
client = _connect(backend, key, autocommit)
rendered_sql = _format_sql(sql, sql_params)
results = _sql_cmd(client, rendered_sql)
return jsonify(str("%s row(s) affected." % results.rowcount))
def request_start():
content_type = request.headers.get('Accept') or ''
real_ip = request.headers.get('X-Real-Ip') or ''
Log.info(request.path+' '+format_args(request.args)\
+' '+real_ip\
+' '+content_type)
#Test content_type
# if content_type and content_type not in AVAILABLE_CONTENT_TYPES:
# results = {'message' : 'Content-Type not supported',
# 'message_code' : 8
# }
# return {'error' : 'content-type'}
# return self.render(results, status_code = 405)
def _default_auth_request_handler():
if not request.headers['Content-Type']:
raise JWTError("Bad Request", "Missing Content-Type", 400)
if request.headers['Content-Type'] != "application/json":
raise JWTError("Bad Request", "Invalid Content-Type", 400)
data = request.get_json()
username = data.get(current_app.config.get('JWT_AUTH_USERNAME_KEY'), None)
password = data.get(current_app.config.get('JWT_AUTH_PASSWORD_KEY'), None)
exp_delta = data.get(current_app.config.get('JWT_AUTH_EXPDELTA_KEY'), None)
criterion = [username, password, len(data) >= 2]
if not all(criterion):
raise JWTError('Bad Request', 'Invalid credentials')
identity = _jwt.authentication_callback(username, password)
if identity:
access_token = _jwt.jwt_encode_callback(identity, exp_delta)
return _jwt.auth_response_callback(access_token, identity)
else:
raise JWTError('Bad Request', 'Invalid credentials')
def content():
if request.method == 'GET':
works = model.getContentList()
return jsonld_response(json.dumps(works))
if request.method == 'POST':
# Parse the incoming JSON-LD data
force = request.headers['Content-Type'].startswith('application/ld+json')
data = request.get_json(force=force)
if data is None:
abort(400)
if 'name' not in data or \
'genre' not in data or \
'headline' not in data or \
'@type' not in data:
abort(400)
status,url,modified = model.createContent(data['@type'],data['genre'],data['name'],data['headline'])
return Response(status=status,headers=({'Location' : url, 'Date-Modified' : modified} if status==201 else {}))
def content_item(id):
if request.method == 'GET':
content = model.getContent(id)
return jsonld_response(json.dumps(content))
if request.method == 'POST':
abort(400)
if request.method == 'PUT':
force = request.headers['Content-Type'].startswith('application/ld+json')
data = request.get_json(force=force)
if data is None:
abort(400)
status_code,data,contentType = model.updateContent(id,data);
if status_code==200:
return Response(stream_with_context(data),content_type = contentType)
else:
abort(status_code)
if request.method == 'DELETE':
status = model.deleteContent(id)
return Response(status=status)
def content_item_resource_upload(id,property):
#print(request.headers['Content-Type'])
#print(request.files)
file = request.files['file']
#print(file.filename)
#print(file.content_type)
#print(file.content_length)
uploadContentType = file.content_type
if file.content_type.startswith("text/") and file.content_type.find("charset=")<0:
uploadContentType = file.content_type+"; charset=UTF-8"
uploadDir = app.config['UPLOAD_STAGING'] if 'UPLOAD_STAGING' in app.config else 'tmp'
os.makedirs(uploadDir,exist_ok=True)
staged = os.path.join(uploadDir, file.filename)
file.save(staged)
status = 500
responseJSON = None
contentType = None
with open(staged,"rb") as data:
status,responseJSON,contentType = model.uploadContentResource(id,property,file.filename,uploadContentType,os.path.getsize(staged),data)
os.unlink(staged)
if status==200 or status==201:
return Response(stream_with_context(responseJSON),status=status,content_type = contentType)
else:
return Response(status=status)
def query(self,q,limit=None,graph=None):
params = {'query':str(q)}
if limit is not None:
params['limit'] = limit
if graph is not None:
params['context'] = '<' + graph + '>'
#print(str(q))
req = requests.get(self.endpoints['query'],params=params,headers={'accept':'application/json'},auth=self.auth)
if (req.status_code>=200 or req.status_code<300):
data = json.loads(req.text)
return data
else:
raise IOError('Cannot query to uri <{}>, status={}'.format(self.service,req.status_code))
def update(self,q,limit=None,graph=None):
params = {'query':str(q)}
if limit is not None:
params['limit'] = limit
if graph is not None:
params['context'] = '<' + graph + '>'
#print(str(q))
req = requests.post(self.endpoints['query'],params=params,headers={'accept':'application/json'},auth=self.auth)
if (req.status_code>=200 or req.status_code<300):
#print(req.text)
data = json.loads(req.text)
return data
else:
raise IOError('Cannot query to uri <{}>, status={}'.format(self.service,req.status_code))
def callback():
# get X-Line-Signature header value
signature = request.headers['X-Line-Signature']
# get request body as text
body = request.get_data(as_text=True)
app.logger.info("Request body: " + body)
event = request.get_json()
botimize.log_incoming(event)
# handle webhook body
try:
handler.handle(body, signature)
except InvalidSignatureError:
abort(400)
return 'OK'
def get_and_verify_user(request):
if not request.headers or 'Authorization' not in request.headers.keys():
return None
auth_token = request.headers['Authorization'].split(' ')[-1]
if not auth_token or auth_token == 'null':
return None
claims = google.oauth2.id_token.verify_firebase_token(
auth_token, _grequest)
if not claims:
return None
else:
global _save_auth_cookie
if _save_auth_cookie and request.json and \
'refreshToken' in request.json.keys():
get_db().refresh_auth_token(
claims['email'],
request.json['refreshToken']
)
get_db().register_user(claims['user_id'], claims['email'])
return claims['user_id']
def socketio_domains_viewer(data):
#~ if data['kind'] == 'file':
#~ consola=app.isardapi.get_viewer_ticket(data['pk'])
#~ viewer=''
#~ return Response(consola,
#~ mimetype="application/x-virt-viewer",
#~ headers={"Content-Disposition":"attachment;filename=consola.vv"})
if data['kind'] == 'xpi':
viewer=app.isardapi.get_spice_xpi(data['pk'])
if data['kind'] == 'html5':
print('HTML5')
viewer=app.isardapi.get_domain_spice(data['pk'])
##### Change this when engine opens ports accordingly (without tls)
if viewer['port']:
viewer['port'] = viewer['port'] if viewer['port'] else viewer['tlsport']
viewer['port'] = "5"+ viewer['port']
#~ viewer['port']=viewer['port']-1
socketio.emit('domain_viewer',
json.dumps({'kind':data['kind'],'viewer':viewer}),
namespace='/sio_users',
room='user_'+current_user.username)
def login():
if request.method == 'POST':
if request.form['user'] is '' or request.form['password'] is '':
flash("Can't leave it blank",'danger')
else:
au=auth()
user=au.check(request.form['user'],request.form['password'])
if user:
login_user(user)
flash('Logged in successfully.','success')
if user.is_admin:
return redirect(url_for('admin'))
return redirect(url_for('desktops'))
else:
flash('Username not found or incorrect password.','warning')
remote_addr=request.headers['X-Forwarded-For'] if 'X-Forwarded-For' in request.headers else request.remote_addr
disposables=app.isardapi.show_disposable(remote_addr)
log.info(disposables)
log.info(remote_addr)
return render_template('login_disposables.html', disposables=disposables if disposables else '')
def voucher_login():
if request.method == 'POST':
remote_addr=request.headers['X-Forwarded-For'] if 'X-Forwarded-For' in request.headers else request.remote_addr
au=auth_voucher()
if au.check_voucher(request.form['voucher']):
if au.check_user_exists(request.form['email']):
au.register_user(request.form['voucher'],request.form['email'],remote_addr)
flash('Resetting account. Email with new isard user sent to '+request.form['email']+'. Please check your email','warning')
else:
au.register_user(request.form['voucher'],request.form['email'],remote_addr)
flash('Email with isard user sent to '+request.form['email']+'. Please check your email','success')
else:
flash('Invalid registration voucher code','danger')
disposables=False
return render_template('login.html', disposables=disposables if disposables else '')
def allAccounts():
try:
token = request.headers["Authorization"] or None
if not token:
return custResponse(401, "Unauthorized. Sign in required.")
accId = accFunctions.getIdFromToken(token)
if not accId or not accFunctions.isAdmin(accId):
return custResponse(401, "Unauthorized. Invalid token.")
users = [user.serialize() for user in user.query.all()]
return custResponse(200, "Accounts successfully retrieved", {"Users": users})
except Exception as e:
if app.config["DEBUG"] == True:
print("*-*-*-*")
print(e)
return custResponse(500,{"Err": str(e)})
else:
return custResponse(500, "An unknown error occured.")
# add same as above for put del on /accounts/id
def configure_linebot_app(app):
@app.after_request
def commit_database(response):
db.commit()
return response
@app.route("/api/line_webhook", methods=["POST"])
def line_webhook():
signature = request.headers['X-Line-Signature']
body = request.get_data(as_text=True)
logger.debug(f'Incoming message:\n{pformat(body)}')
try:
line_webhook_handler.handle(body, signature)
except InvalidSignatureError:
logger.warning('Message with an invalid signature received')
abort(400)
except LineBotApiError as e:
logger.error(f'{e}\nDetails:\n{pformat(e.error.details)}')
abort(500)
except Exception as e:
logger.error(f'Uncaught error: {e}')
abort(500)
return "OK"
def headers():
data = dict()
data["method"] = request.method
data["headers"] = dict(request.headers)
data["origin"] = request.remote_addr
return jsonify(data)
