import datetime
from flask_restplus import Resource
from flask_jwt_extended import create_access_token, create_refresh_token, jwt_required, jwt_refresh_token_required, get_jwt_identity, get_raw_jwt
from lost.api.api import api
from lost.api.user.api_definition import user, user_list, user_login
from lost.api.user.parsers import login_parser, create_user_parser, update_user_parser
from lost.settings import LOST_CONFIG, FLASK_DEBUG
from lost.db import access, roles
from lost.db.model import User as DBUser, Role, Group
from lost.logic import email
from lost.logic.user import release_user_annos
from flaskapp import blacklist
namespace = api.namespace('user', description='Users in System.')
@namespace.route('')
@api.doc(description='User Api get method.')
class UserList(Resource):
@api.marshal_with(user_list)
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
users = dbm.get_users()
for us in users:
for g in us.groups:
from flask_restplus import Resource
from flask import request
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.settings import LOST_CONFIG, FLASK_DEBUG
from lost.db import access, roles
from lost.api.annotask.parsers import annotask_parser
from lost.logic import anno_task as annotask_service
import logging
logger = logging.getLogger(__name__)
namespace = api.namespace('annotask', description='AnnoTask API.')
@namespace.route('')
class Available(Resource):
#@api.marshal_with(anno_task_list)
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
group_ids = [g.idx for g in user.groups]
annotask_list = annotask_service.get_available_annotasks(
dbm, group_ids, identity)
dbm.close_session()
import json
from flask import request
from flask_restplus import Resource, Mask
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.api.pipeline.api_definition import templates, template, pipelines, pipeline
from lost.api.pipeline import tasks
from lost.api.label.api_definition import label_trees
from lost.db import roles, access
from lost.settings import LOST_CONFIG, DATA_URL
from lost.logic.pipeline import service as pipeline_service
from lost.logic import template as template_service
from lost.utils.dump import dump
namespace = api.namespace('pipeline', description='Pipeline API.')
@namespace.route('/template')
class TemplateList(Resource):
@api.marshal_with(templates)
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
re = template_service.get_templates(dbm)
dbm.close_session()
return re
is_root=True)
rootlabel.parent_leaf_id = None
dbm.save_obj(rootlabel)
for l in ['Parenchyma', 'Emphysema', 'Ground glass', 'Crazy Paving', 'Consolidation']:
label = model.LabelLeaf(name=l,
abbreviation=None,
description=None,
external_id=None,
parent_leaf_id=rootlabel.idx,
is_root=False)
dbm.save_obj(label)
dbm.close_session()
namespace = api.namespace('label', description='Label API.')
@namespace.route('/tree')
class LabelTrees(Resource):
#@api.marshal_with()
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
root_leaves = dbm.get_all_label_trees()
trees = list()
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.api.mia.api_definition import mia_anno
from lost.api.label.api_definition import label_trees
from lost.db import roles, access
from lost.settings import LOST_CONFIG
from lost.logic import mia
import json
import cv2
import base64
from lost.logic.file_man import FileMan
from lost.pyapi.utils import anno_helper
from lost.logic import mia
from lost.logic import dask_session
namespace = api.namespace('mia', description='MIA Annotation API.')
@namespace.route('/next/<int:max_amount>')
class Next(Resource):
#@api.marshal_with(mia_anno)
@jwt_required
def get(self, max_amount):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
from posix import POSIX_FADV_NOREUSE
from flask_restx import Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.settings import LOST_CONFIG
from lost.db import access, roles
import lost
import os
namespace = api.namespace('system',
description='System information and control.')
@namespace.route('/version')
class Version(Resource):
def get(self):
try:
return lost.__version__
except:
return 'development'
@namespace.route('/jupyter')
class JupyterLabUrl(Resource):
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
from flask_restx import Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.api.worker.api_definition import worker_list
from lost.settings import LOST_CONFIG
from lost.db import access, roles
namespace = api.namespace('worker', description='Workers in System.')
@namespace.route('')
@api.doc(description='Worker Api get method.')
class WorkerList(Resource):
@api.marshal_with(worker_list)
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
workers = dbm.get_worker()
dbm.close_session()
wlist = {'workers': workers}
return wlist
from flask import request
from flask_restplus import Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.api.sia.api_definition import sia_anno, sia_config, sia_update
from lost.api.label.api_definition import label_trees
from lost.db import roles, access
from lost.settings import LOST_CONFIG, DATA_URL
from lost.logic import sia
import json
namespace = api.namespace('sia', description='SIA Annotation API.')
@namespace.route('/first')
class First(Resource):
@api.marshal_with(sia_anno)
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
re = sia.get_first(dbm, identity, DATA_URL)
dbm.close_session()
return re
from datetime import time, datetime
import json
from flask import request
from flask_restx import Resource
from lost.api.api import api
from lost.settings import LOST_CONFIG, DATA_URL
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.db import model, roles, access
from lost.logic.file_man import FileMan, chonkyfy
from fsspec.registry import known_implementations
import os
namespace = api.namespace('fb', description='Lost Filebrowser API')
@namespace.route('/ls')
class LS(Resource):
@jwt_required
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
data = json.loads(request.data)
fs_db = dbm.get_fs(name=data['fs']['name'])
fm = FileMan(fs_db=fs_db)
commonprefix = os.path.commonprefix(
from flask import request
from flask_restplus import Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.api.group.api_definition import group, group_list
from lost.api.group.parsers import group_parser
from lost.db import model, roles, access
from lost.settings import LOST_CONFIG
namespace = api.namespace('group', description='Groups in System.')
@namespace.route('')
class GroupList(Resource):
@api.marshal_with(group_list)
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.DESIGNER):
dbm.close_session()
return "You are not authorized.", 401
else:
glist = {'groups': dbm.get_user_groups(user_defaults=False)}
dbm.close_session()
return glist
@api.expect(group_parser)
@jwt_required
def post(self):
import json
from flask import request
from flask_restx import Resource
from lost.api.api import api
from lost.settings import LOST_CONFIG, DATA_URL
from lost.db.vis_level import VisLevel
from lost.logic.file_man import FileMan
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.db import model, roles, access
import lost_ds as lds
import numpy as np
import cv2
import base64
import random
namespace = api.namespace('annoExample',
description='API to get annotation examples')
@namespace.route('/getAnnoExample')
class GetAnnoExample(Resource):
@jwt_required
def post(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.ANNOTATOR), 401
else:
import json
from flask import request, make_response
from flask_restx import Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.db import access, roles
from lost.settings import LOST_CONFIG
from lost.logic.project_config import ProjectConfigMan
from lost.api.config.api_definition import config
namespace = api.namespace('config', description='Config Interface')
dbm = access.DBMan(LOST_CONFIG)
project_config = ProjectConfigMan(dbm)
configs = project_config.get_all()
db_key_list = [el['key'] for el in configs]
key = "integer_test"
if not key in db_key_list:
project_config.create_entry(key,
None,
1,
default=60,
description="integer_test description",
config=json.dumps({
'type': 'number',
'min': 50,
'max': 100
}))
key = "float_test"
if not key in db_key_list:
project_config.create_entry(key,
from flask_restplus import Resource
from flask import request, send_from_directory
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.api.api import api
from lost.settings import LOST_CONFIG, FLASK_DEBUG
from lost.db import access, roles
from lost.api.annotask.parsers import annotask_parser
from lost.logic import anno_task as annotask_service
import os
namespace = api.namespace('data', description='Data API.')
@namespace.route('/<path:path>')
class Data(Resource):
@jwt_required
def get(self, path):
print(path)
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You are not authorized.", 401
else:
return send_from_directory(
os.path.join(LOST_CONFIG.project_path, 'data'), path)
@namespace.route('/logs/<path:path>')
from datetime import time, datetime
import json
from flask import request
from flask_restx import Resource
from lost.api.api import api
from lost.settings import LOST_CONFIG, DATA_URL
from flask_jwt_extended import jwt_required, get_jwt_identity
from lost.db import model, roles, access
from lost.logic.statistics import personal
namespace = api.namespace('statistics', description='LOST Statistics API')
@namespace.route('/personal')
class Personal(Resource):
@jwt_required
def get(self):
dbm = access.DBMan(LOST_CONFIG)
identity = get_jwt_identity()
user = dbm.get_user_by_id(identity)
if not user.has_role(roles.ANNOTATOR):
dbm.close_session()
return "You need to be {} in order to perform this request.".format(
roles.DESIGNER), 401
else:
from lost.api.statistics.example_data import example_stats
example_stats['annos'] = personal.get_annotation_stats(
dbm, user.idx)
example_stats['labels'] = personal.get_annos_per_label(
dbm, user.idx)
example_stats['types'] = personal.get_annos_per_type(dbm, user.idx)
