def insert_admin_account() -> None: """Insert default admin account.""" user_email = '*****@*****.**' password = '******' password_hash = hash_password(password) with db_session() as session: user_exists = session.query( exists().where(User.email == user_email)).scalar() if user_exists: logger.warning('Admin user already exists with email "%s"', user_email) return role = Role.query.filter_by(name='admin').first() if not role: logger.error( 'Role not found! You have probably forgot to apply fixtures.') return user = User(user_email, password_hash, 'Admin', 'Medtagger') user.roles.append(role) session.add(user) logger.info('User added with email "%s" and password "%s"', user_email, password)
def add_new_user(new_user: User) -> int: """Add new user. :return: id of the new user """ with db_session() as session: session.add(new_user) return new_user.id
def add_new_label(scan_id: ScanID, user: User, labeling_time: LabelingTime) -> Label: """Add new Label for given Scan.""" with db_session() as session: label = Label(user, labeling_time) label.scan_id = scan_id session.add(label) return label
def get_task_by_key(key: str) -> Task: """Fetch Task from database. :param key: key for a Task :return: Task object """ with db_session() as session: task = session.query(Task).filter(Task.key == key).first() return task
def get_dataset_by_key(key: str) -> Dataset: """Fetch Dataset from database. :param key: key for a Dataset :return: Dataset object """ with db_session() as session: dataset = session.query(Dataset).filter(Dataset.key == key).one() return dataset
def reduce_number_of_declared_slices(scan_id: ScanID) -> None: """Decrease number of declared Slices by one.""" with db_session() as session: query = session.query(Scan) query = query.filter(Scan.id == scan_id) query.update({ "declared_number_of_slices": (Scan.declared_number_of_slices - 1) })
def add_slice(self, orientation: SliceOrientation = SliceOrientation.Z) -> 'Slice': """Add new slice into this Scan. :return: ID of a Slice """ with db_session() as session: new_slice = Slice(orientation) new_slice.scan = self session.add(new_slice) return new_slice
def unassign_label_tag(tag: LabelTag, task_key: str) -> None: """Unassign Label Tag from Task. :param tag: tag that should be unassigned from Task :param task_key: key that will identify such Task """ with db_session(): task = Task.query.filter(Task.key == task_key).one() task.available_tags.remove(tag) task.save()
def get_slices_by_scan_id(scan_id: ScanID, orientation: SliceOrientation = SliceOrientation.Z) -> List[Slice]: """Fetch Slice from database.""" with db_session() as session: query = session.query(Slice) query = query.join(Scan) query = query.filter(Scan.id == scan_id) query = query.filter(Slice.orientation == orientation) query = query.order_by(Slice.location) slices = query.all() return slices
def get_category_by_key(key: str) -> ScanCategory: """Fetch Scan Category from database. :param key: key for a Scan Category :return: Scan Category object """ with db_session() as session: category = session.query(ScanCategory).filter( ScanCategory.key == key).one() return category
def assign_label_tag(tag: LabelTag, task_key: str) -> None: """Assign existing Label Tag to Task. :param tag: tag that should be assigned to Task :param task_key: key that will identify such Task """ with db_session(): task = Task.query.filter(Task.key == task_key).one() task.available_tags.append(tag) task.save()
def add_new_dataset(key: str, name: str) -> Dataset: """Add new Dataset to the database. :param key: key that will identify such Dataset :param name: name that will be used in the Use Interface for such Dataset :return: Dataset object """ with db_session() as session: dataset = Dataset(key, name) session.add(dataset) return dataset
def increase_skip_count_of_a_scan(scan_id: ScanID) -> bool: """Increase skip_count of a Scan with given scan_id. :param scan_id: ID of a Scan which skip_count should be increased :return: boolean information whether the Scan was skipped or not """ with db_session() as session: query = session.query(Scan) query = query.filter(Scan.id == scan_id) updated = query.update({"skip_count": (Scan.skip_count + 1)}) return bool(updated)
def add_new_tag(key: str, name: str) -> LabelTag: """Add new Label Tag to the database. :param key: key that will identify such Label Tag :param name: name that will be used in the User Interface for such Label Tag :return: Label Tag object """ with db_session() as session: label_tag = LabelTag(key, name) session.add(label_tag) return label_tag
def add_new_category(key: str, name: str, image_path: str) -> ScanCategory: """Add new Scan Category to the database. :param key: key that will identify such Scan Category :param name: name that will be used in the Use Interface for such Scan Category :param image_path: path to the image that represents such Scan Category (used in User Interface) :return: Scan Category object """ with db_session() as session: category = ScanCategory(key, name, image_path) session.add(category) return category
def delete_slice(_slice: Slice) -> None: """Remove Slice from SQL database and Storage.""" slice_id = _slice.id scan_id = _slice.scan_id with db_session() as session: query = session.query(Scan).filter(Scan.id == scan_id) query.update({'declared_number_of_slices': Scan.declared_number_of_slices - 1}) session.query(Slice).filter(Slice.id == slice_id).delete() OriginalSlice.filter(id=slice_id).delete() ProcessedSlice.filter(id=slice_id).delete()
def add_new_scan(category: ScanCategory, number_of_slices: int, user: Optional[User]) -> Scan: """Add new Scan to the database. :param category: Scan's Category object :param number_of_slices: number of Slices that will be uploaded :param user: User that uploaded scan :return: Scan object """ with db_session() as session: scan = Scan(category, number_of_slices, user) session.add(scan) return scan
def set_user_role(user_id: int, role_name: str) -> None: """Set user's role. Old role will be replaced.""" try: user = UsersRepository.get_user_by_id(user_id) except NoResultFound: raise InvalidArgumentsException('User with this id does not exist.') try: role = RolesRepository.get_role_with_name(role_name) except NoResultFound: raise InvalidArgumentsException('Role with this name does not exist.') with db_session() as session: user.roles = [role] session.add(user)
def insert_user_roles() -> None: """Insert default user Roles.""" with db_session() as session: for row in ROLES: role_name = row.get('name', '') role_exists = session.query( exists().where(Role.name == role_name)).scalar() if role_exists: logger.info('Role exists with name "%s"', role_name) continue role = Role(**row) session.add(role) logger.info('Role added for name "%s"', role_name)
def insert_scan_categories() -> None: """Insert all default Scan Categories if don't exist.""" with db_session() as session: for row in CATEGORIES: category_key = row.get('key', '') category_exists = session.query( exists().where(ScanCategory.key == category_key)).scalar() if category_exists: logger.info('Scan Category exists with key "%s"', category_key) continue category = ScanCategory(**row) session.add(category) logger.info('Scan Category added for key "%s"', category_key)
def add_new_scan(dataset: Dataset, number_of_slices: int, user: User = None) -> Scan: """Add new Scan to the database. :param dataset: Dataset object :param number_of_slices: number of Slices that will be uploaded :param user: (optional) User that uploaded scan :return: Scan object """ with db_session() as session: scan = Scan(dataset, number_of_slices, user) session.add(scan) return scan
def add_new_point_label_element(label_id: LabelID, position: LabelPosition, label_tag: LabelTag) -> LabelElementID: """Add new Point Element for given Label. :param label_id: Label's ID :param position: position (x, y, slice_index) of the Label :param label_tag: Label Tag object :return: ID of a Element """ with db_session() as session: point_label_element = PointLabelElement(position, label_tag) point_label_element.label_id = label_id session.add(point_label_element) return point_label_element.id
def add_new_tag(key: str, name: str, tools: List[LabelTool], task_id: TaskID) -> LabelTag: """Add new Label Tag to the database. :param key: key that will identify such Label Tag :param name: name that will be used in the User Interface for such Label Tag :param tools: list of tools for given LabelTag that will be available on labeling page :param task_id: id of Task that owns this Label Tag :return: Label Tag object """ with db_session() as session: label_tag = LabelTag(key, name, tools) label_tag.task_id = task_id session.add(label_tag) return label_tag
def add_action_response(action_id: ActionID, response: Dict) -> ActionResponse: """Add response for given Action.""" action = Action.query.filter(Action.id == action_id).one() if action.action_type == 'Survey': valid = action.validate_response(response) if not valid: raise InvalidResponseException( 'Your answers does not match keys in Survey.') with db_session() as session: survey_id = cast(SurveyID, action_id) action_response = SurveyResponse(survey_id, response) session.add(action_response) else: raise UnsupportedActionException( 'Action does not support returning Respose.') return action_response
def _clear_databases() -> None: logger.info('Removing all data from PostgreSQL.') with db_session() as sess: for table in reversed(Base.metadata.sorted_tables): sess.execute( 'TRUNCATE TABLE "{}" RESTART IDENTITY CASCADE;'.format( table.name)) session.close_all() logger.info('Removing all data from Cassandra.') storage_session = storage.create_session() storage_session.set_keyspace(storage.MEDTAGGER_KEYSPACE) for model_name in dir(models): model = getattr(models, model_name) if issubclass(model.__class__, ModelMetaClass) and model.__table_name__: storage_session.execute('TRUNCATE {}'.format(model.__table_name__))
def add_new_rectangular_label_element( label_id: LabelID, position: LabelPosition, shape: LabelShape, label_tag: LabelTag) -> LabelElementID: """Add new Rectangular Element for given Label. :param label_id: Label's ID :param position: position (x, y, slice_index) of the Label :param shape: shape (width, height) of the Label :param label_tag: Label Tag object :return: ID of a Element """ with db_session() as session: rectangular_label_element = RectangularLabelElement( position, shape, label_tag) rectangular_label_element.label_id = label_id session.add(rectangular_label_element) return rectangular_label_element.id
def add_task(key: str, name: str, image_path: str, datasets_keys: List[str], tags: List[LabelTag]) -> Task: """Add new Task to the database. :param key: key that will identify such Task :param name: name that will be used in the Use Interface for such Task :param image_path: path to the image that represents such Task (used in User Interface) :param datasets_keys: Keys of Datasets that Task takes Scans from :param tags: Label Tags that will be created and assigned to Task :return: Task object """ with db_session() as session: task = Task(key, name, image_path) datasets = Dataset.query.filter( Dataset.key.in_(datasets_keys)).all() # type: ignore task.datasets = datasets task.available_tags = tags session.add(task) return task
def add_new_brush_label_element(label_id: LabelID, slice_index: int, width: int, height: int, image: bytes, label_tag: LabelTag) -> LabelElementID: """Add new Brush Element for given Label. :param label_id: Label's ID :param width: width of the Label's image :param height: height of the Label's image :param image: bytes with image representation of a binary mask :param label_tag: Label Tag object :return: ID of a Element """ # pylint: disable=too-many-arguments with db_session() as session: brush_label_element = BrushLabelElement(slice_index, width, height, label_tag) brush_label_element.label_id = label_id session.add(brush_label_element) BrushLabelElementStorage.create(id=brush_label_element.id, image=image) return brush_label_element.id
def insert_labels_tags() -> None: """Insert all default Label Tags if they don't exist and assign them to category.""" with db_session() as session: for row in TAGS: tag_key = row.get('key', '') tag_exists = session.query( exists().where(LabelTag.key == tag_key)).scalar() if tag_exists: logger.info('Label Tag exists with key "%s"', tag_key) continue tag = LabelTag(row.get('key', ''), row.get('name', '')) tag_category_key = row.get('category_key', '') category = session.query(ScanCategory).filter( ScanCategory.key == tag_category_key).one() tag.scan_category_id = category.id session.add(tag) logger.info( 'Label Tag added for key "%s" and assigned to category for key "%s"', tag_key, tag_category_key)
def update(key: str, name: str = None, tools: List[LabelTool] = None, task_id: TaskID = None) -> LabelTag: """Update Tools that are available in Label Tag. :param key: key that will identify such Label Tag :param name: (optional) new name for such Label Tag :param tools: (optional) list of tools for given LabelTag that will be available on labeling page :param task_id: (optional) Task ID for another Task which should be linked to this Label Tag :return: Label Tag object """ with db_session() as session: label_tag = get_label_tag_by_key(key) if name: label_tag.name = name if tools: label_tag.tools = tools if task_id: label_tag.task_id = task_id session.add(label_tag) return label_tag