def test_can_exclude_annotations_with_null_tags(self): with self._session(): user = User.create(**user1()) user_id = user.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = sound(user) sound_id = snd.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = next(s.filter(Sound.id == sound_id)) annotation = Annotation.create( creator=user, created_by=user, sound=snd, start_seconds=1, duration_seconds=1, tags=['drums'], data_url=None) Annotation.create( creator=user, created_by=user, sound=snd, start_seconds=1, duration_seconds=1, tags=None, data_url=None) with self._session() as s: annotations = list(s.filter(Annotation.tags != [])) self.assertEqual(1, len(annotations)) self.assertEqual(annotation.id, annotations[0].id)
def __init__(self, mid): Annotation.__init__(self, mid, name=u"Informação Simples", mtype=InformationAnnotation.TYPE) self.notification_icon_file = None self.notification_icon_duration = None self.information_media = None self.information_media_timestamp = None self.information_media_duration = None
def save_experiment(self, data): """ Try to save results into MongoDB :param metabolites_by_feature: :param data @return: None """ logging.info("Saving experiment in mongo db...") mongo = os.environ.get('MONGOHQ_URL') if mongo is not None : connect('hola', host=mongo) else: connect('omicsservices') exp = MetabolomicsExperiment() #exp.parameters = "All the xcms file goes here" exp.organization = data.get('organization', "IMS") exp.description = data['description'] #get('description', '') exp.title = data.get('title', "Alzeihmer") exp.software = data.get('software', "XCMS") exp.version = data.get('version', "3.18") exp.save() for p in self.peakels: ft = Feature() if p.main_attribution is not None: ft.main_attribution = p.main_attribution.attribution else: ft.main_attribution = self._get_main_putative_attribution(p) for k, v in p.area_by_sample_name.items(): ab = Abundance(sample=k, abundance=v) ft.abundances.append(ab) #ft.attributions = p.attributions for m in p.annotations: annot = Annotation() annot.annotation = m.metabolite.name annot.score1 = m.score_isos annot.score2 = m.score_network ft.annotations.append(annot) ft.mass = p.moz ft.rt = p.rt ft.experiment_id = exp ft.save() logging.info("Done.")
def test_can_store_and_retrieve_with_no_data_url(self): with self._session(): user = User.create(**user1()) user_id = user.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = sound(user) sound_id = snd.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = next(s.filter(Sound.id == sound_id)) annotation = Annotation.create( creator=user, created_by=user, sound=snd, start_seconds=1, duration_seconds=1, tags=['drums'], data_url=None) annotation_id = annotation.id with self._session(): annotation = next(s.filter(Annotation.id == annotation_id)) self.assertIsNone(annotation.data_url)
def test_error_when_setting_computed_field(self): with self._session(): user = User.create(**user1()) user_id = user.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = sound(user) sound_id = snd.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = next(s.filter(Sound.id == sound_id)) annotation = Annotation.create( creator=user, created_by=user, sound=snd, start_seconds=1, duration_seconds=1, tags=['drums'], data_url=None) def x(): annotation.end_seconds = 10 self.assertRaises(ImmutableError, x)
def get_model_example(self, content_type): dataset = User.create( user_name='HalIncandenza', password='******', email='*****@*****.**', user_type=UserType.DATASET, about_me='Tennis 4 Life') snd = Sound.create( creator=dataset, created_by=dataset, info_url='https://example.com/sound', audio_url='https://example.com/sound/file.wav', low_quality_audio_url='https://example.com/sound/file.mp3', license_type=LicenseType.BY, title='A sound', duration_seconds=12.3, tags=['test']) annotations = [ Annotation.create( creator=dataset, created_by=dataset, sound=snd, start_seconds=1, duration_seconds=1, tags=['kick'] ), Annotation.create( creator=dataset, created_by=dataset, sound=snd, start_seconds=2, duration_seconds=1, tags=['snare'] ), ] results = build_list_response( actor=dataset, items=annotations, total_count=100, add_next_page=True, link_template=self.link_template(dataset.id), page_size=2, page_number=2) return JSONHandler(AppEntityLinks()) \ .serialize(results, content_type).decode()
def on_post(self, req, resp, sound_id, session, actor): """ description: Create a new annotation for the sound with identifier `sound_id`. Text tags can be added directly to the resource via the `tags` field, or arbitrary binary or other structured data may be pointed to via the `data_url` parameter. url_params: sound_id: The identifier of the sound to annotate example_request_body: python: get_example_post_body responses: - status_code: 201 description: Successful annotation creation - status_code: 400 description: Input model validation error - status_code: 404 description: Provided an invalid `sound_id` - status_code: 401 description: Unauthorized request - status_code: 403 description: User is not permitted to create annotations """ sound = session.find_one(Sound.id == sound_id) annotations_key = 'annotations' annotations = req.media.get(annotations_key) if not annotations: error = ValueError( 'You must provide one or more ' 'annotations in field "annotations"') raise CompositeValidationError((annotations_key, error)) for annotation in annotations: annotation['created_by'] = actor annotation['sound'] = sound Annotation.create( creator=actor, **annotation) resp.set_header('Location', f'/sounds/{sound_id}/annotations') resp.status = falcon.HTTP_CREATED
def on_get(self, req, resp, session, actor): """ description: Get a list of annotations query_params: page_size: The number of results per page page_number: The page of results to view low_id: Only return identifiers occurring later in the series than this one order: If `desc`, return results from most to least recent, if `asc` return results from least to most recent. tags: Only return annotations with all specified tags with_tags: Only return annotations that have at least one tag, generally excluding dense features computed by featurebots. This parameter is mutually exclusive with `tags` and will be ignored if it is present. responses: - status_code: 200 description: Successfully fetched an annotation example: python: get_example_list_model - status_code: 401 description: Unauthorized request - status_code: 403 description: User is not permitted to access this annotation """ query = Annotation.all_query() # TODO: This is near-duplicate code from the /sounds resource below. # factor it out additional_params = {} tags = req.get_param_as_list('tags') with_tags = req.get_param_as_bool('with_tags') if tags: # look for specific tags additional_params['tags'] = tags for tag in tags: query = query & (Annotation.tags == tag) elif with_tags: # only ensure that some tags are present additional_params['with_tags'] = with_tags query = query & (Annotation.tags != []) list_entity( req, resp, session, actor, query, Annotation, self.LINK_TEMPLATE, additional_params=additional_params)
def on_get(self, req, resp, session): """ description: Return some high-level stats about users, sounds and annotations responses: - status_code: 200 example: python: get_model_example description: Successfully fetched stats """ resp.media = self._get_model( total_sounds=session.count(Sound.all_query()), total_annotations=session.count(Annotation.all_query()), total_users=session.count(User.all_query()), ) resp.status = falcon.HTTP_200
def save_data_annotate(): req_body = request.get_json() if req_body is None or "path_file" not in req_body: return abort(400) file_name = req_body["path_file"] if '..' in file_name: return abort(400) if "get" in req_body: try: # print(req_body) sopiuid = req_body["sopiuid"] path_file = os.path.basename(req_body["path_file"]) siuid = req_body["siuid"] file_auto_analysis = "/root/tuannm/dicom-server/data/json_machine/{}__{}__{}.json".format(siuid, sopiuid, path_file) print("Read Auto analysis file: {}".format(file_auto_analysis)) _logger.info("Read Auto analysis file: {}".format(file_auto_analysis)) with open(file_auto_analysis, 'r') as fr: data = json.load(fr) fr.close() return jsonify(status=True, data=data) except Exception as e: # _logger.info(f"GO TO get_auto_analysis: {req_body}") _logger.error(e) return {'status': False, 'error': e}, 500 try: req_body["timestamp"] = datetime.datetime.now().strftime("%s") savedfile_path, savedfile_location = Annotation.save(req_body) print("Saved file: {}".format(savedfile_path)) _logger.info("Save file: {}".format(savedfile_path)) return jsonify(status=True, data=urllib.parse.urljoin( request.host_url, urllib.parse.quote(savedfile_location) )) except Exception as e: _logger.error(e) return {'status': False, 'error': e}, 500
def test_created_by_user_name_is_computed(self): with self._session(): user = User.create(**user1()) user_id = user.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = sound(user) sound_id = snd.id with self._session() as s: user = next(s.filter(User.id == user_id)) snd = next(s.filter(Sound.id == sound_id)) annotation = Annotation.create( creator=user, created_by=user, sound=snd, start_seconds=1, duration_seconds=1, tags=['drums'], data_url=None) self.assertEqual(user.user_name, annotation.created_by_user_name)
def test_permissions_error_when_creator_is_aggregator(self): with self._session(): creator = User.create(**user1(user_type=UserType.HUMAN)) creator_id = creator.id aggregator = User.create(**user1(user_type=UserType.AGGREGATOR)) aggregator_id = aggregator.id with self._session() as s: creator = s.find_one(User.id == creator_id) snd = sound(creator) snd_id = snd.id with self._session() as s: snd = s.find_one(Sound.id == snd_id) aggregator = s.find_one(User.id == aggregator_id) self.assertRaises(PermissionsError, lambda: Annotation.create( creator=aggregator, created_by=aggregator, sound=snd, start_seconds=1, duration_seconds=1, tags=['drums'], data_url=None ))