def testYAMLAliases(self):
folderModel = Folder()
aliasedFolders = list(folderModel.find({'name': 'Common'}, force=True))
self.assertTrue(len(aliasedFolders) == 2)
for folder in aliasedFolders:
self.assertTrue(
len(list(folderModel.childItems(folder, force=True))) == 2)
def testYAMLAliases(self):
folderModel = Folder()
aliasedFolders = list(folderModel.find({'name': 'Common'}, force=True))
self.assertTrue(len(aliasedFolders) == 2)
for folder in aliasedFolders:
self.assertTrue(
len(list(folderModel.childItems(folder, force=True))) == 2
)
def iterateItems(self, doc, **kwargs):
"""Iterate over all items under the given document."""
folder = Folder()
item = Item()
for child in item.find({'folderId': doc['_id']}):
yield child
for child in folder.find({'parentId': doc['_id']}):
for subchild in self.iterateItems(child, **kwargs):
yield subchild
def findAllImages(user=None, baseFolder=None):
folderModel = Folder()
q = {'meta.slicerCLIType': 'image'}
if baseFolder:
q['parentId'] = baseFolder['_id']
if user:
imageFolders = folderModel.findWithPermissions(
q, user=user, level=AccessType.READ)
else:
imageFolders = folderModel.find(q)
images = []
for imageFolder in imageFolders:
qt = {'meta.slicerCLIType': 'tag', 'parentId': imageFolder['_id']}
if user:
tagFolders = folderModel.findWithPermissions(
qt, user=user, level=AccessType.READ)
else:
tagFolders = folderModel.find(qt)
for tagFolder in tagFolders:
images.append(DockerImageItem(imageFolder, tagFolder, user))
return images
def findSharedDatasetFolders(currentUser):
folderModel = Folder()
groupModel = ModelImporter.model('group')
datasetSharingGroup = groupModel.findOne(
query={'name': PluginSettings.DATASET_SHARING_GROUP_NAME})
if not datasetSharingGroup:
raise AccessException('user group "{0}" doesn\'t exist'.format(
PluginSettings.DATASET_SHARING_GROUP_NAME))
if datasetSharingGroup['_id'] not in currentUser['groups']:
raise AccessException(
'user doesn\'t belong to user group "{0}"'.format(
PluginSettings.DATASET_SHARING_GROUP_NAME))
folders = folderModel.find({
'baseParentType': 'user',
'parentCollection': 'user',
'access.groups.id': datasetSharingGroup['_id'],
'name': PluginSettings.MINERVA_SHARED_DATASET
})
return folders
class LabelResource(Resource):
def __init__(self):
super().__init__()
self.resourceName = 'label'
self.ann_file_name = "annotation.json"
self.coll_m = Collection()
self.file_m = File()
self.folder_m = Folder()
self.item_m = Item()
self.upload_m = Upload()
self.asset_m = Assetstore()
self.setupRoutes()
def setupRoutes(self):
self.route('GET', (), handler=self.getLabelList)
self.route('GET', (':label_id',), self.getLabel)
self.route('GET', ('meta',), self.getLabelMeta)
self.route('GET', ('create',), self.createLabelFile)
self.route('GET', ('by_name',), self.getLabelByName)
self.route('POST', (), self.postLabel)
# ############# PUBLIC METHODS ##################
@access.public
@autoDescribeRoute(
Description('Get label list').param('assign_id', 'assignment folder id'))
@rest.rawResponse
@trace
def getLabelList(self, assign_id):
files = self.folder_m.fileList(assign_id, user=self.getCurrentUser(), data=False,
includeMetadata=True, mimeFilter=['application/json'])
files = list(files)
cherrypy.response.headers["Content-Type"] = "application/json"
return dumps(files)
@access.public
@autoDescribeRoute(
Description('Create a new label file inside the label folder if it doesnt exist')
.param('assign_id', 'the parent folder id')
.param('name', 'image name for which we are creating this label file'))
@rest.rawResponse
@trace
def createLabelFile(self, assign_id, name):
p_folder = self.folder_m.load(id=assign_id,
user=self.getCurrentUser(),
level=AccessType.WRITE)
label_folder = find_folder(p_folder=p_folder,
name=name,
user=self.getCurrentUser(),
desc="Label Folder",
create=True)
file = find_file(p_folder=label_folder,
name=self.ann_file_name,
user=self.getCurrentUser(),
assetstore=self.asset_m.getCurrent(),
create=False)
if not file:
file = create_new_file(p_folder=label_folder,
name=self.ann_file_name,
user=self.getCurrentUser(),
assetstore=self.asset_m.getCurrent())
config_file = self.__find_config(assign_id)
if not config_file:
printFail("No config file found")
return errorMessage("No config file found")
else:
res = copy_file(src_file=config_file,
dest_file=file,
user=self.getCurrentUser())
return dumps({
"label_id": res['fileId']
})
return dumps({
"label_id": file['_id']
})
@access.public
@autoDescribeRoute(
Description('Get labels by file_name')
.param('name', 'label file name')
.param('assign_id', 'the assignment id'))
@rest.rawResponse
@trace
def getLabelByName(self, name, assign_id):
p_folder = self.folder_m.load(assign_id,
user=self.getCurrentUser(),
level=AccessType.READ)
label_folder = find_folder(p_folder=p_folder,
name=name,
user=self.getCurrentUser(),
desc="Label Folder",
create=True)
# this file is created in <assign_folder>/<label_folder>/assignment.json
file = find_file(p_folder=label_folder,
name=self.ann_file_name,
user=self.getCurrentUser(),
assetstore=self.asset_m.getCurrent(),
create=False)
cherrypy.response.headers["Content-Type"] = "application/json"
if file:
return self.file_m.download(file)
else:
return dumps({})
@access.public
@autoDescribeRoute(
Description('Get label file by id')
.param('label_id', 'label file id'))
@rest.rawResponse
@trace
def getLabel(self, label_id):
file = self.file_m.load(label_id, level=AccessType.READ, user=self.getCurrentUser())
printOk2(file)
cherrypy.response.headers["Content-Type"] = "application/json"
return self.file_m.download(file)
@access.public
@autoDescribeRoute(
Description('Get label meta data by id')
.param('label_id', 'label file id'))
@trace
def getLabelMeta(self, label_id):
file = self.file_m.load(label_id, level=AccessType.READ, user=self.getCurrentUser())
cherrypy.response.headers["Content-Type"] = "application/json"
return dumps(file)
@access.public
@autoDescribeRoute(
Description('Post to label file by id')
.param('label_id', 'label file id')
.param('labels', 'labels to be updated'))
@rest.rawResponse
@trace
def postLabel(self, label_id, labels):
file = self.file_m.load(label_id, level=AccessType.WRITE, user=self.getCurrentUser())
cherrypy.response.headers["Content-Type"] = "application/json"
params = {'labels': json.loads(labels)}
data = json.dumps(params, indent=2, sort_keys=True)
upload = writeData(self.getCurrentUser(), file, data)
printOk2(file)
printOk(upload)
return dumps(upload)
# ############# PRIVATE METHODS ##################
def __create_new_file(self, folder, file_name):
item = self.item_m.createItem(file_name,
creator=self.getCurrentUser(),
folder=folder,
description='label file',
reuseExisting=False)
file = self.file_m.createFile(size=0,
item=item,
name=file_name,
creator=self.getCurrentUser(),
assetstore=self.asset_m.getCurrent(),
mimeType="application/json")
return file
@staticmethod
def __get_owner_id(folder):
aclList = Folder().getFullAccessList(folder)
for acl in aclList['users']:
if acl['level'] == AccessType.ADMIN:
return str(acl['id'])
return None
def __get_config_folder(self, label_folder_id):
label_folder = Folder().load(label_folder_id,
user=self.getCurrentUser(),
level=AccessType.READ)
ownerId = self.__get_owner_id(label_folder)
config_folder = self.folder_m.load(label_folder['meta'][ownerId], level=AccessType.READ,
user=self.getCurrentUser())
return config_folder
def __find_config(self, folder_id):
folder = self.__get_config_folder(folder_id)
printOk2("Config folder {}".format(folder))
files = self.folder_m.fileList(folder, self.getCurrentUser(), data=False)
for file_path, file in files:
printOk(file)
if file['name'] == "config.json":
return file
def __findFolder(self, p_folder, name, desc="", create=False):
"""
Find folder by name. If not found create the folder
:param p_folder: parent folder
:param name: name of the folder you want to find inside the parent folder
:return: folder doc
"""
folder = list(self.folder_m.find({'folderId': p_folder['_id'], 'name': name}).limit(1))
if not folder:
# check if you are allowed to create, else return nothing
if create:
folder = self.folder_m.createFolder(parent=p_folder,
name=name,
creator=self.getCurrentUser(),
description=desc,
reuseExisting=True)
else:
return None
return folder
def __findFile(self, folder, file_name):
item = list(self.item_m.find({'folderId': folder['_id'], 'name': file_name}).limit(1))
if not item:
return None
item = item[0]
file = list(self.file_m.find({'itemId': item['_id']}).limit(1))
if not file:
return None
return file[0]
def find(self, query=None, annotator_user=None, state=None, **kwargs):
study_query = self._find_query_filter(query, annotator_user, state)
return Folder.find(self, study_query, **kwargs)
class AssignmentResource(Resource):
def __init__(self):
super().__init__()
self.coll_m = Collection()
self.file_m = File()
self.folder_m = Folder()
self.item_m = Item()
self.upload_m = Upload()
self.asset_m = Assetstore()
self.user_m = User()
self.setupRoutes()
def setupRoutes(self):
self.route('GET', (), handler=self.list)
self.route('GET', (':a_id',), handler=self.getAssignment)
self.route('GET', ('admin_data',), handler=self.getAdminData)
def __findName(self, folder):
imageFolder = self.__findImageFolder(folder)
if isinstance(imageFolder, dict):
return imageFolder['name']
return ""
def __findImageFolder(self, folder):
owner = self.__findOwner(folder)
ret = ""
if self.folder_m.getAccessLevel(folder, self.getCurrentUser()) == AccessType.ADMIN:
# this folder was created by this user, and so it will contain the images
# printFail(folder)
ret = folder
else:
meta = folder['meta']
# this is the label file, and so should only have one entry in the metadata
assert len(meta) == 1
# that one entry contains link to the image folder, key must be the creator of this folder
assert str(owner['_id']) in meta, (str(owner['_id']), meta)
ret = self.folder_m.load(meta[str(owner['_id'])],
level=AccessType.READ,
user=self.getCurrentUser())
return ret
def __findLabelFolder(self, folder):
owner = self.__findOwner(folder)
ret = []
if self.folder_m.getAccessLevel(folder, self.getCurrentUser()) == AccessType.ADMIN:
# this folder was created by this user, so it will contain images
if 'meta' not in folder:
return []
meta = folder['meta']
for k, v in meta.items():
ret.append(self.folder_m.load(v, level=AccessType.READ, user=self.getCurrentUser()))
else:
# this folder was not created by this user, so it will contain labels
ret = [folder]
return ret
def __findOwner(self, folder):
aclList = Folder().getFullAccessList(folder)
for acl in aclList['users']:
if acl['level'] == AccessType.ADMIN:
return self.user_m.load(str(acl['id']), level=AccessType.READ, user=self.getCurrentUser())
return None
@access.public
@autoDescribeRoute(
Description('Get list of all assignments that it owns or is a part of')
.param('limit', 'Number of assignments to return')
.param('offset', 'offset from 0th assignment to start looking for assignments'))
@rest.rawResponse
def list(self, limit, offset):
try:
printOk((limit, offset))
ret = self.__list(int(limit), int(offset))
cherrypy.response.headers["Content-Type"] = "application/json"
return dumps(ret)
except:
printFail(traceback.print_exc)
def __list(self, limit=0, offset=0):
user = self.getCurrentUser()
folders = self.folder_m.find({'parentId': user['_id'],
'parentCollection': 'user'}, limit=limit, offset=offset)
ret = []
for folder in folders:
if self.__findName(folder):
ret.append({'name': self.__findName(folder),
'image_folder': self.__findImageFolder(folder),
'label_folders': self.__findLabelFolder(folder),
'owner': self.__findOwner(folder)})
return ret
def __getAssignment(self, _id):
assignments = self.__list()
for assignment in assignments:
# printOk2(assignment)
if str(assignment['image_folder']['_id']) == _id:
return assignment
return None
def __getAnnotators(self, assignment):
ret = []
for label_folder in assignment['label_folders']:
printOk(label_folder)
ret.append({
'user': self.user_m.load(label_folder['parentId'], user=self.getCurrentUser(), level=AccessType.READ),
'expanded': False,
})
return ret
@access.public
@autoDescribeRoute(
Description('Get assignment by id').param('a_id', 'folder id that controls the assignment'))
@rest.rawResponse
def getAssignment(self, a_id):
try:
assignment = self.__getAssignment(a_id)
return dumps(assignment)
except:
printFail(traceback.print_exc)
@access.public
@autoDescribeRoute(
Description('Get admin data associated with assignment id').param('a_id',
'folder id that controls the assignment'))
@rest.rawResponse
def getAdminData(self, a_id):
try:
assignment = self.__getAssignment(a_id)
if assignment['owner']['_id'] == self.getCurrentUser()['_id']:
# then current user is this assignment's admin
return dumps({'annotators': self.__getAnnotators(assignment)})
except:
printFail(traceback.print_exc)
def find(self, query=None, **kwargs):
dataset_query = self._find_query_filter(query)
return Folder.find(self, dataset_query, **kwargs)
class AssignmentResource(Resource):
def __init__(self):
super().__init__()
self.coll_m = Collection()
self.file_m = File()
self.folder_m = Folder()
self.item_m = Item()
self.upload_m = Upload()
self.asset_m = Assetstore()
self.user_m = User()
self.setupRoutes()
def setupRoutes(self):
self.route('GET', (), handler=self.list)
self.route('GET', (':a_id',), handler=self.getAssignment)
self.route('GET', ('admin_data',), handler=self.getAdminData)
def __findName(self, folder):
imageFolder = self.__findImageFolder(folder)
if isinstance(imageFolder, dict):
return imageFolder['name']
return ""
def __findImageFolder(self, folder):
owner = self.__findOwner(folder)
ret = ""
if self.folder_m.getAccessLevel(folder, self.getCurrentUser()) == AccessType.ADMIN:
# this folder was created by this user, and so it will contain the images
# printFail(folder)
ret = folder
else:
meta = folder['meta']
# this is the label file, and so should only have one entry in the metadata
assert len(meta) == 1
# that one entry contains link to the image folder, key must be the creator of this folder
assert str(owner['_id']) in meta, (str(owner['_id']), meta)
ret = self.folder_m.load(meta[str(owner['_id'])],
level=AccessType.READ,
user=self.getCurrentUser())
return ret
def __findLabelFolder(self, folder):
owner = self.__findOwner(folder)
ret = []
if self.folder_m.getAccessLevel(folder, self.getCurrentUser()) == AccessType.ADMIN:
# this folder was created by this user, so it will contain images
if 'meta' not in folder:
return []
meta = folder['meta']
for k, v in meta.items():
ret.append(self.folder_m.load(v, level=AccessType.READ, user=self.getCurrentUser()))
else:
# this folder was not created by this user, so it will contain labels
ret = [folder]
return ret
def __findOwner(self, folder):
aclList = Folder().getFullAccessList(folder)
for acl in aclList['users']:
if acl['level'] == AccessType.ADMIN:
return self.user_m.load(str(acl['id']), level=AccessType.READ, user=self.getCurrentUser())
return None
@access.public
@autoDescribeRoute(
Description('Get list of all assignments that it owns or is a part of')
.param('limit', 'Number of assignments to return')
.param('offset', 'offset from 0th assignment to start looking for assignments'))
@rest.rawResponse
def list(self, limit, offset):
try:
printOk((limit, offset))
ret = self.__list(int(limit), int(offset))
cherrypy.response.headers["Content-Type"] = "application/json"
return dumps(ret)
except:
printFail(traceback.print_exc)
def __list(self, limit=0, offset=0):
user = self.getCurrentUser()
folders = self.folder_m.find({'parentId': user['_id'],
'parentCollection': 'user'}, limit=limit, offset=offset)
ret = []
for folder in folders:
if self.__findName(folder):
ret.append({'name': self.__findName(folder),
'image_folder': self.__findImageFolder(folder),
'label_folders': self.__findLabelFolder(folder),
'owner': self.__findOwner(folder)})
return ret
def __getAssignment(self, _id):
assignments = self.__list()
for assignment in assignments:
# printOk2(assignment)
if str(assignment['image_folder']['_id']) == _id:
return assignment
return None
def __getAnnotators(self, assignment):
ret = []
for label_folder in assignment['label_folders']:
printOk(label_folder)
ret.append({
'user': self.user_m.load(label_folder['parentId'], user=self.getCurrentUser(), level=AccessType.READ),
'expanded': False,
})
return ret
@access.public
@autoDescribeRoute(
Description('Get assignment by id').param('a_id', 'folder id that controls the assignment'))
@rest.rawResponse
def getAssignment(self, a_id):
try:
assignment = self.__getAssignment(a_id)
return dumps(assignment)
except:
printFail(traceback.print_exc)
@access.public
@autoDescribeRoute(
Description('Get admin data associated with assignment id').param('a_id',
'folder id that controls the assignment'))
@rest.rawResponse
def getAdminData(self, a_id):
try:
assignment = self.__getAssignment(a_id)
if assignment['owner']['_id'] == self.getCurrentUser()['_id']:
# then current user is this assignment's admin
return dumps({'annotators': self.__getAnnotators(assignment)})
except:
printFail(traceback.print_exc)
