def do_job_allocate():
job_ids = get_job_list()
user_ids = get_user_list()
header = {"Authorization": "JWT %s" % get_jwt('convert')}
# 列表shuffle，现阶段按序排列，以对应医生答题顺序
# random.shuffle(job_ids)
delta = 10
lst = [job_ids[i: i + delta] for i in range(0, len(job_ids), delta)]
for index, user in enumerate(user_ids):
print("Allocating jobs to user-%s" % user)
items = lst[index]
for item in items:
job = {
'profile': user,
'tiff': item,
}
response = requests.post('http://%s/api/v1/missions/' % HOST, json=job, headers=header)
if response.status_code == 201:
pass
else:
raise Exception(response.json())
def tiles():
try:
auth = get_jwt()
return jsonify_data([
{
"title": "HoneyPot Dashboard",
"description": "Patrick Vertical Histogram",
"periods": [
"last_hour",
"last_7_days",
"last_30_days"
],
"default_period": "last_7_days",
"tags": [
"pat",
"ip_addresses"
],
"type": "vertical_bar_chart",
"short_description": "The number of bad IP addresses",
"id": "vertical_histogram"
},
{
"description": "SecureX IP Blocking List",
"tags": [
"pat"
],
"type": "donut_graph",
"short_description": "SecureX IP Blocking List",
"title": "IP Feed Breakdown",
"default_period": "last_7_days",
"id": "donut"
}
])
except:
return jsonify_data([])
def intra_system_delete(self, request_url, headers=None):
if not headers: headers = dict()
if not 'Authorization' in headers:
headers['Authorization'] = 'Bearer %s' % utils.get_jwt(self.environ)
actual_url = utils.set_resource_host_header(str(request_url), headers)
logger.debug('intra_system_delete request_url: %s actual_url: %s headers: %s', request_url, actual_url, headers)
return requests.delete(actual_url, headers=headers, verify=False)
def tile_data():
_ = get_jwt()
req = get_json(DashboardTileDataSchema())
print(green(req["tile_id"], bold=True))
if req['tile_id'] == 'test-line-chart-graph':
return jsonify_data(payload_for_line_chart)
if req['tile_id'] == 'something_else':
return jsonify_data(response2)
def intra_system_put(self, request_url, data, headers=None):
if not headers: headers = dict()
if not 'Authorization' in headers:
headers['Authorization'] = 'Bearer %s' % utils.get_jwt(self.environ)
if not 'Content-Type' in headers:
headers['Content-Type'] = 'application/rdf+json+ce'
actual_url = utils.set_resource_host_header(str(request_url), headers)
logger.debug('intra_system_put request_url: %s actual_url: %s headers: %s data: %s', request_url, actual_url, headers,data)
return requests.put(actual_url, headers=headers, data=json.dumps(data, cls=rdf_json.RDF_JSON_Encoder), verify=False)
def intra_system_get(self, request_url, headers=None):
if not headers: headers = dict()
actual_url = utils.set_resource_host_header(str(request_url), headers)
if not 'Authorization' in headers:
headers['Authorization'] = 'Bearer %s' % utils.get_jwt(self.environ)
if not 'Accept' in headers:
headers['Accept'] = 'application/rdf+json+ce'
logger.debug('intra_system_get request_url: %s actual_url: %s headers: %s', request_url, actual_url, headers)
return requests.get(actual_url, headers=headers)
def get_user_list():
"""
获取 用户列表
:return:
"""
header = {"Authorization": "JWT %s" % get_jwt('convert')}
response = requests.get('http://%s/api/v1/profiles/?type=1' % HOST, headers=header)
if response.status_code == 200:
ids = [item['id'] for item in response.json()]
return ids
else:
raise Exception(response.json())
def read_and_update(path):
header = {"Authorization": "JWT %s" % get_jwt('convert')}
with open(path) as f:
tiff_name = os.path.splitext(os.path.basename(path))[0]
tiff_name = tiff_name.replace("_clas", '')
print("Processing on %s..." % tiff_name)
image = None
for item in ['.kfb', '.tif']:
response = requests.get('http://%s/api/v1/images/?name=%s' %
(HOST, tiff_name + item),
headers=header)
if response.status_code == 200 and response.json():
data = response.json()
if data:
image = data[0]['id']
break
else:
raise Exception("NO TIFF NAMED %s" % tiff_name)
reader = csv.reader(f, delimiter=',')
next(reader)
for line in reader:
x_y, label_yolo, accuracy_yolo, label_xception, accuracy_xception, xmin, ymin, xmax, ymax = line
x0, y0 = x_y.split('_')
x0, y0, accuracy, xmin, ymin, xmax, ymax = int(x0), int(y0), float(
accuracy_xception), float(xmin), float(ymin), float(
xmax), float(ymax)
x, y, w, h = x0 + xmin, y0 + ymin, xmax - xmin, ymax - ymin
label = {
'image': image,
'cell_type': label_xception,
'accuracy': accuracy,
'x': x,
'y': y,
'w': w,
'h': h,
'source_type': "AI",
}
response = requests.post('http://%s/api/v1/labels/' % HOST,
json=label,
headers=header)
if response.status_code == 201:
pass
else:
raise Exception(response.json())
def tiles():
try:
auth = get_jwt()
return jsonify_data([{
"id": "paris_temperature",
"type": "metric_group",
"title": "Real Paris Temperature",
"periods": ["last_24_hours"],
"short_description": "Paris Temperature",
"description": "A longer description",
"tags": ["test"],
}])
except:
return jsonify_data([])
def registry():
data = request.get_json(force=True)
if isinstance(data, str):
data = json.loads(data)
schema = UserSchema(data)
try:
user = schema.save()
jwt = utils.get_jwt()
access_token = jwt.jwt_encode_callback(user)
return jwt.auth_response_callback(access_token, user)
except InvalidDataException as ex:
return utils.json_abort({
'message': ex.message,
'fields': ex.fields
}, 400)
def get_github_token():
"""
Returns the github auth token, updates if it has expired.
:return: github token
"""
global gh_token, gh_token_expiry
# 3 minutes buffer
if gh_token_expiry - 180 > time.time():
print(f"using github token: {gh_token[:22]}")
return gh_token
print("updating github token")
private_pem = os.environ['PRIVATE_PEM']
jwt = get_jwt(os.environ['APP_ID'], private_pem)
response = get_installation_access_token(jwt, os.environ['INST_ID']).json()
gh_token = response["token"]
gh_token_expiry = dt.strptime(response["expires_at"],
"%Y-%m-%dT%H:%M:%S%z").timestamp()
print(f"github token updated: {gh_token[:22]}")
return gh_token
def get_job_list():
"""
获取 病理图像信息列表
:return:
"""
header = {"Authorization": "JWT %s" % get_jwt('convert')}
with open("ZHENGZHOU_COMPETITION_SLIDES.txt") as f:
lines = [line.replace("\n", "") for line in f.readlines()]
ids = []
for line in lines:
response = requests.get('http://%s/api/v1/images/all/?case_no=%s' % (HOST, line), headers=header)
if response.status_code == 200:
obj = response.json()[0]
ids.append(obj['id'])
else:
raise Exception(response.json())
return ids
def login():
if current_identity:
return utils.json_abort({'message': 'User has already logged in'}, 400)
data = request.get_json(force=True)
if isinstance(data, str):
data = json.loads(data)
username = data.get('username', None)
password = data.get('password', None)
if not username or not password:
raise JWTError('Bad Request', 'Invalid credentials')
identity = authenticate(username, password)
jwt = utils.get_jwt()
if identity:
access_token = jwt.jwt_encode_callback(identity)
return jwt.auth_response_callback(access_token, identity)
else:
raise JWTError('Bad Request', 'Invalid credentials')
def tiles():
try:
auth = get_jwt()
return jsonify_data([
{
"description": "A Markdown Tile",
"periods": [
"last_hour"
],
"tags": [
"test",
"test2"
],
"type": "markdown",
"short_description": "Shows some markdown stuff",
"title": "Markdown ASA Interfaces Status",
"id": "markdown_tile"
}
])
except:
return jsonify_data([])
def process_IN_CLOSE_WRITE(self, event):
# logging.info("create file: %s " % os.path.join(event.path, event.name))
# 处理成小图片，然后发送给grpc服务器或者发给kafka
file_path = os.path.join(event.path, event.name)
print('文件完成写入', file_path)
basename, postfix = os.path.splitext(event.name)
if postfix in ACCEPTED_PATHOLOGY_IMAGE_TYPES:
image = {
"name": event.name,
"case_no": os.path.splitext(event.name)[0],
"path": event.path,
"status": "CREATED",
}
header = {"Authorization": "JWT %s" % get_jwt('convert')}
response = requests.post('http://%s/api/v1/images/' % HOST, json=image, headers=header)
if response.status_code == 201:
pass
else:
print(response.json())
def tile_data():
_ = get_jwt()
req = get_json(DashboardTileDataSchema())
print (green(req,bold=True))
print (green(req["tile_id"],bold=True))
if req['tile_id'] == 'vertical_histogram':
if req['period'] == 'last_7_days':
data=gen_bar_chart_data(7)
elif req['period'] == 'last_30_days':
data=gen_bar_chart_data(30)
else:
data=gen_bar_chart_data(1)
donnees=gen_json_for_bar_chart(data,"vertical_histogram","timestamp")
#print(cyan(donnees,bold=True))
return jsonify_data(donnees)
if req['tile_id'] == 'donut':
data=donut()
info=gen_json_for_donut(data,"donut_tile")
return jsonify_data(info)
elif req['tile_id'] == 'raas':
return jsonify_data(response_six)
def tile_data():
_ = get_jwt()
req = get_json(DashboardTileDataSchema())
print(green(req["tile_id"], bold=True))
if req['tile_id'] == 'paris_temperature':
date, hour, temp = paris_temperature()
return jsonify_data({
"observed_time": {
"start_time": "2020-12-19T00:07:00.000Z",
"end_time": "2021-01-18T00:07:00.000Z",
},
"valid_time": {
"start_time": "2021-01-18T00:07:00.000Z",
"end_time": "2021-01-18T00:12:00.000Z",
},
"data": [
{
"icon": "brain",
"label": "Date",
"value": date,
"value-unit": "string",
},
{
"icon": "percent",
"label": "hour",
"value": hour,
"value-unit": "string",
},
{
"icon": "percent",
"label": "Temperature",
"value": temp,
"value-unit": "integer",
},
],
"cache_scope":
"org",
})
def tiles():
try:
auth = get_jwt()
return jsonify_data([{
"description":
"DONUTS",
"periods": [
"last_24_hours", "last_7_days", "last_30_days", "last_60_days",
"last_90_days"
],
"tags": ["AWS"],
"type":
"donut_graph",
"short_description":
"DONUTS",
"title":
"Patrick DONUT",
"default_period":
"last_7_days",
"id":
"donut_tile"
}])
except:
return jsonify_data([])
def tile_data():
_ = get_jwt()
req = get_json(DashboardTileDataSchema())
print(green(req["tile_id"], bold=True))
if req['tile_id'] == 'donut_tile':
return jsonify_data(response_two)
def tile():
_ = get_jwt()
_ = get_json(DashboardTileSchema())
return jsonify_data({})
resp = json.loads(r.text)
print("Activations response: %s" % (resp))
print('Activations requests thread stopping.')
p = 'tests/data/01_sm_csv/01'
date_start = '2012-06-15T00:00'
date_end = '2012-06-15T23:59'
step = 5
plot_step = 600
# Create jwt
config = configparser.ConfigParser()
config.read('ini/eeris.ini')
secret = config['REST']['jwt_psk']
token = utils.get_jwt('orchestrator', secret)
prefix = 'jwt'
# Just select the first installation for the demo.
inst = config['eeRIS']['inst_ids'].split(',')[0].strip()
nilm_url = 'http://localhost:8000/nilm/' + inst
inst_url = 'http://localhost:8000/installation/' + inst + '/model'
# Prepare data
delete = False
if config['eeRIS']['input_method'] == 'rest':
phase_list, power = eco.read_eco(p, date_start, date_end)
delete = True
# Delete model at database and the server memory (optional)
if delete:
from datetime import datetime, timezone, timedelta
from urllib.parse import urlparse, parse_qs
import uuid
import requests
from utils import get_jwt, config
if __name__ == "__main__":
JWT = get_jwt()
BASE_URL = "https://api.tilisy.com"
REDIRECT_URL = config["redirectUrl"]
# we are going to use that bank for reference
BANK_NAME = "Nordea"
BANK_COUNTRY = "FI"
base_headers = {"Authorization": f"Bearer {JWT}"}
application_response = requests.get(f"{BASE_URL}/application",
headers=base_headers)
print(f"Application data: {application_response.json()}")
aspsps_response = requests.get(f"{BASE_URL}/aspsps", headers=base_headers)
# If you want, you can override BANK_NAME and BANK_COUNTRY with any bank from this list
print(f"ASPSPS data: {aspsps_response.json()}")
start_authorization_body = {
"access": {
"valid_until":
(datetime.now(timezone.utc) + timedelta(days=10)).isoformat()
},
"aspsp": {
"name": BANK_NAME,
def return_task_queue():
global task_queue
return task_queue
def return_result_queue():
global result_queue
return result_queue
# 从BaseManager继承的QueueManager:
class QueueManager(BaseManager):
pass
HEADER = {"Authorization": "JWT %s" % get_jwt('convert')}
def get_game_status():
response = requests.get('http://%s/api/v1/game/' % HOST, headers=HEADER)
if response.status_code == 200 and response.json():
data = response.json()
status = data['status']
if status == "1":
return 1
else:
return 0
else:
raise Exception(response.json())
