def get_or_create_cc_parameterset(self, create=True): """ Gets the creative commons parameterset for the experiment :param create: If true, creates a new parameterset object to hold the cc license if one doesn't exist :type create: boolean :return: The parameterset manager for the cc parameterset :rtype: :class:`tardis.tardis_portal.ParameterSetManager. ParameterSetManager` """ parameterset = ExperimentParameterSet.objects.filter( schema__namespace=self.schema, experiment__id=self.experiment_id) if not len(parameterset): if create: experiment = Experiment.objects.get(id=self.experiment_id) self.psm = ParameterSetManager(schema=self.schema, parentObject=experiment) else: return None else: self.psm = ParameterSetManager(parameterset=parameterset[0]) return self.psm
def _get_params(self, key, namespace, experiment): parameterset = ExperimentParameterSet.objects.filter( schema__namespace=namespace, experiment__id=experiment.id) if parameterset: psm = ParameterSetManager(parameterset=parameterset[0]) return psm.get_params(key, True) return []
def testHandlesSingleEntry(self): from ..views import SCHEMA_URI psm = ParameterSetManager(parentObject=self.experiment, schema=SCHEMA_URI) params = { 'type': 'website', 'identifier': 'https://www.google.com/', 'title': 'Google', 'notes': 'This is a note.' } for k, v in params.items(): psm.set_param(k, v) response = self.client.get( reverse('tardis.apps.related_info.views.' + 'list_or_create_related_info', args=[self.experiment.id])) expect(response.status_code).to_equal(200) expect(response['Content-Type'])\ .to_equal('application/json; charset=utf-8') objs = json.loads(response.content) expect(len(objs)).to_be(1) for k in params.keys(): expect(objs[0][k]).to_equal(params[k])
def testHandlesMultipleEntries(self): from ..views import SCHEMA_URI param_list = ({'type': 'website', 'identifier': 'https://www.example.test/%d' % i, 'title': 'Title #%d' % i, 'notes': 'This is note #%d.' % i} for i in range(10)) for params in param_list: psm = ParameterSetManager(parentObject=self.experiment, schema=SCHEMA_URI) for k, v in params.items(): psm.set_param(k, v) response = self.client.get( reverse('tardis.apps.related_info.views.' + 'list_or_create_related_info', args=[self.experiment.id])) expect(response.status_code).to_equal(200) expect(response['Content-Type'])\ .to_equal('application/json; charset=utf-8') objs = json.loads(response.content) expect(len(objs)).to_be(10) for obj in objs: expect(obj['type']).to_equal('website') expect(obj['identifier']).to_match(r'www.example.test/\d+$') expect(obj['title']).to_match(r'^Title #\d+$') expect(obj['notes']).to_match(r'note #\d+\.$')
def test_link_parameter_type(self): """ Test that Parameter.link_gfk (GenericForeignKey) is correctly assigned after using Parameter.set_value(some_url) for a LINK Parameter. """ psm = ParameterSetManager(parameterset=self.datafileparameterset) # Check link to experiment exp_url = self.exp.get_absolute_url() # /experiment/view/1/ self.assertTrue(psm.get_param("exp_link").string_value == exp_url) self.assertTrue(psm.get_param("exp_link").link_id == self.exp.id) exp_ct = ContentType.objects.get(model__iexact="experiment") self.assertTrue(psm.get_param("exp_link").link_ct == exp_ct) self.assertTrue(psm.get_param("exp_link").link_gfk == self.exp) # Check link to dataset dataset_url = self.dataset.get_absolute_url() # /dataset/1/ self.assertTrue( psm.get_param("dataset_link").string_value == dataset_url) self.assertTrue( psm.get_param("dataset_link").link_id == self.dataset.id) dataset_ct = ContentType.objects.get(model__iexact="dataset") self.assertTrue(psm.get_param("dataset_link").link_ct == dataset_ct) self.assertTrue(psm.get_param("dataset_link").link_gfk == self.dataset)
def test_new_parameterset(self): psm = ParameterSetManager(parentObject=self.datafile, schema="http://localhost/psmtest/df2/") self.assertTrue( psm.get_schema().namespace == "http://localhost/psmtest/df2/") psm.set_param("newparam1", "test3", "New Parameter 1") self.assertTrue(psm.get_param("newparam1").string_value == "test3") self.assertTrue( psm.get_param("newparam1").name.full_name == "New Parameter 1") psm.new_param("newparam1", "test4") self.assertTrue(len(psm.get_params("newparam1", True)) == 2) psm.set_param_list("newparam2", ("a", "b", "c", "d")) self.assertTrue(len(psm.get_params("newparam2")) == 4) psm.set_params_from_dict({"newparam2": "test5", "newparam3": 3}) self.assertTrue(psm.get_param("newparam2", True) == "test5") # the newparam3 gets created and '3' is set to a string_value # since once cannot assume that an initial numeric value # will imply continuing numeric type for this new param self.assertTrue(psm.get_param("newparam3").string_value == '3') psm.delete_params("newparam1") self.assertTrue(len(psm.get_params("newparam1", True)) == 0)
def _create_experiment(user, bad): experiment = Experiment(title='Norwegian Blue', description='Parrot + 40kV', created_by=user) experiment.public_access = Experiment.PUBLIC_ACCESS_METADATA experiment.save() experiment.author_experiment_set.create( order=0, author="John Cleese", url="http://nla.gov.au/nla.party-1") experiment.author_experiment_set.create( order=1, author="Michael Palin", url="http://nla.gov.au/nla.party-2") psm = ParameterSetManager(parentObject=experiment, schema=SCHEMA_URI) if bad: params = { 'type': 'website', 'identifier': 'https://www.badexample.com/' } else: params = { 'type': 'website', 'identifier': 'https://www.example.com/', 'title': 'Google', 'notes': 'This is a note.' } for k, v in params.items(): psm.set_param(k, v) return experiment
def _get_dict_from_ps(self, ps): ''' Build dictionary by getting the parameter values from the keys, then zipping it all together. ''' psm = ParameterSetManager(ps) return dict([('id', ps.id)] + # Use set ID zip(self.parameter_names, (psm.get_param(k, True) for k in self.parameter_names)))
def test_existing_parameterset(self): psm = ParameterSetManager(parameterset=self.datafileparameterset) self.assertTrue(psm.get_schema().namespace\ == "http://localhost/psmtest/df/") self.assertTrue(psm.get_param("parameter1").string_value == "test1") self.assertTrue(psm.get_param("parameter2", True) == 2)
def test_tz_naive_date_handling(self): ''' Ensure that dates are handling in a timezone-aware way. ''' psm = ParameterSetManager(parameterset=self.datafileparameterset) psm.new_param("parameter3", datetime(1970,01,01,10,0,0)) expect(psm.get_param("parameter3", True))\ .to_equal(datetime(1970,01,01,0,0,0,tzinfo=pytz.utc))
def save_datafile_add_form(schema, parentObject, request): psm = ParameterSetManager(schema=schema, parentObject=parentObject) for key, value in sorted(request.POST.iteritems()): if value: stripped_key = key.replace('_s47_', '/') stripped_key = stripped_key.rpartition('__')[0] psm.new_param(stripped_key, value)
def get_related_info(ps): psm = ParameterSetManager(ps) parameter_names = ['type','identifier','title','notes'] try: return dict([('id', ps.id)] + # Use set ID zip(parameter_names, (psm.get_param(k, True) \ for k in parameter_names))) except ExperimentParameter.DoesNotExist: return dict() # drop Related_Info record with missing fields
def test_tz_aware_date_handling(self): """ Ensure that dates are handling in a timezone-aware way. """ psm = ParameterSetManager(parameterset=self.datafileparameterset) psm.new_param("parameter3", '1970-01-01T08:00:00+08:00') expect(psm.get_param("parameter3", True))\ .to_equal(datetime(1970, 01, 01, 0, 0, 0, tzinfo=pytz.utc))
def save_metadata(self, datafile, schema, metadata): psm = ParameterSetManager(parentObject=datafile.dataset, schema=schema.namespace) psm.set_param('metadata-filename', datafile.filename) for key, value in metadata: try: psm.set_param(key, value) except ValueError, e: pn = ParameterName.objects.get(name=key, schema=schema) psm.set_param(key, value.strip(pn.units))
def _get_param(self, key, namespace, experiment): parameterset = ExperimentParameterSet.objects.filter( schema__namespace=namespace, experiment__id=experiment.id) if len(parameterset) > 0: psm = ParameterSetManager(parameterset=parameterset[0]) try: return psm.get_param(key, True) except MultipleObjectsReturned: return psm.get_params(key, True) except ObjectDoesNotExist: return None
def get_related_info(ps): psm = ParameterSetManager(ps) parameter_names = ['type', 'identifier', 'title', 'notes'] try: parameters = { key: psm.get_param(key, True) for key in parameter_names} parameters['id'] = ps.id return parameters except ExperimentParameter.DoesNotExist: return dict() # drop Related_Info record with missing fields
def save_datafile_edit_form(parameterset, request): psm = ParameterSetManager(parameterset=parameterset) psm.delete_all_params() for key, value in sorted(request.POST.iteritems()): if value: stripped_key = key.replace('_s47_', '/') stripped_key = stripped_key.rpartition('__')[0] psm.new_param(stripped_key, value)
def _create_related_info(request, experiment_id): if not authz.has_write_permissions(request, experiment_id): return return_response_error(request) form = RelatedInfoForm(json.loads(request.body)) if not form.is_valid(): return HttpResponse('', status=400) ps = ExperimentParameterSet(experiment_id=experiment_id, schema=_get_schema()) ps.save() ParameterSetManager(ps).set_params_from_dict(form.cleaned_data) return HttpResponse(json.dumps(_get_dict_from_ps(ps)), content_type='application/json; charset=utf-8', status=201)
def _create(self, request, experiment_id): from tardis.tardis_portal.auth.decorators import has_experiment_write if not has_experiment_write(request, experiment_id): return return_response_error(request) form = self.form_cls(json.loads(request.body)) if not form.is_valid(): return HttpResponse('', status=400) ps = ExperimentParameterSet(experiment_id=experiment_id, schema=self.schema) ps.save() ParameterSetManager(ps).set_params_from_dict(form.cleaned_data) return HttpResponse(json.dumps(self._get_dict_from_ps(ps)), content_type='application/json; charset=utf-8', status=201)
def testPersisterStoresEntryMetadata(self): # Create user to associate with dataset user = User(username="******") user.save() feed, entry = self._getTestEntry() p = AtomPersister() dataset = p.process(feed, entry) parameterset = dataset.getParameterSets() \ .get(schema=AtomImportSchemas. \ get_schema(Schema.DATASET)) expect(parameterset) != None psm = ParameterSetManager(parameterset) expect(psm.get_param('EntryID').get()).to_equal(entry.id) expect(psm.get_param('Updated').name.isDateTime()).to_be_truthy() # Compare against non-timezoned update time expect(psm.get_param('Updated', True)) \ .to_equal(iso8601.parse_date(entry.updated))
def _update_related_info(request, experiment_id, related_info_id): if not authz.has_write_permissions(request, experiment_id): return return_response_error(request) form = RelatedInfoForm(json.loads(request.body)) if not form.is_valid(): return HttpResponse('', status=400) try: ps = ExperimentParameterSet.objects.get(experiment_id=experiment_id, id=related_info_id) except ExperimentParameterSet.DoesNotExist: return HttpResponse('', status=404) ParameterSetManager(ps).set_params_from_dict(form.cleaned_data) return HttpResponse(json.dumps(_get_dict_from_ps(ps)), content_type='application/json; charset=utf-8', status=201)
def test_unresolvable_link_parameter(self): """ Test that LINK Parameters that can't be resolved to a model (including non-URL values) still work. """ self.datafileparameterset3 = DatafileParameterSet( schema=self.schema, datafile=self.datafile) self.datafileparameterset3.save() psm = ParameterSetManager(parameterset=self.datafileparameterset3) # Create a Parameter of type LINK to an unresolvable (non-URL) # free-text value self.freetext_link_param = DatafileParameter( parameterset=self.datafileparameterset3, name=self.parametername_unresolvable_link) self.assertRaises( SuspiciousOperation, lambda: self.freetext_link_param.set_value("FREETEXT_ID_123"))
def testHandlesFound(self): from ..views import SCHEMA_URI psm = ParameterSetManager(parentObject=self.experiment, schema=SCHEMA_URI) params = {'type': 'website', 'identifier': 'https://www.google.com/', 'title': 'Google', 'notes': 'This is a note.'} for k, v in params.items(): psm.set_param(k, v) response = self.client.get( reverse('tardis.apps.related_info.views.' + 'get_or_update_or_delete_related_info', args=[self.experiment.id, psm.parameterset.id])) expect(response.status_code).to_equal(200) obj = json.loads(response.content) for k, v in params.items(): expect(obj[k]).to_equal(v)
def testJEOLComplex(self): JEOLSEMFilter()(None, instance=self.datafiles[1]) # Check a parameter set was created dataset = Dataset.objects.get(id=self.dataset.id) expect(dataset.getParameterSets().count()).to_equal(1) # Check all the expected parameters are there psm = ParameterSetManager(dataset.getParameterSets()[0]) expect(psm.get_param('metadata-filename', True))\ .to_equal(self.datafiles[1].filename) expect(psm.get_param('instrument', True)).to_equal('7001F_TTL') expect(psm.get_param('accel_volt', True)).to_equal(15.0) expect(psm.get_param('micron_bar', True)).to_equal(213) expect(psm.get_param('micron_marker', True)).to_equal(100) # Check we won't create a duplicate dataset JEOLSEMFilter()(None, instance=self.datafiles[1]) dataset = Dataset.objects.get(id=self.dataset.id) expect(dataset.getParameterSets().count()).to_equal(1)
def test_link_parameter_type_extra(self): # make a second ParameterSet for testing some variations # in URL values self.datafileparameterset2 = DatafileParameterSet( schema=self.schema, datafile=self.datafile) self.datafileparameterset2.save() psm = ParameterSetManager(parameterset=self.datafileparameterset2) self.dataset_link_param2 = DatafileParameter( parameterset=self.datafileparameterset2, name=self.parametername_dataset_link) # /dataset/1 - no trailing slash dataset_url = self.dataset.get_absolute_url() self.dataset_link_param2.set_value(dataset_url) self.dataset_link_param2.save() # Check link_id/link_ct/link_gfk to dataset self.assertTrue( psm.get_param("dataset_link").link_id == self.dataset.id) dataset_ct = ContentType.objects.get(model__iexact="dataset") self.assertTrue(psm.get_param("dataset_link").link_ct == dataset_ct) self.assertTrue(psm.get_param("dataset_link").link_gfk == self.dataset) # Test links of the form /api/v1/experiment/<experiment_id>/ self.exp_link_param2 = DatafileParameter( parameterset=self.datafileparameterset2, name=self.parametername_exp_link) exp_url = '/api/v1/experiment/%s/' % self.exp.id self.exp_link_param2.set_value(exp_url) self.exp_link_param2.save() # Check link_id/link_ct/link_gfk to experiment self.assertTrue(psm.get_param("exp_link").link_id == self.exp.id) exp_ct = ContentType.objects.get(model__iexact="experiment") self.assertTrue(psm.get_param("exp_link").link_ct == exp_ct) self.assertTrue(psm.get_param("exp_link").link_gfk == self.exp)
def testFlexstationSimple(self): """ Simple test running the filter and making sure the Softmax version number was saved """ filter = FlexstationFilter("Flexstation Test Schema", "http://rmit.edu.au/flexstation_test") filter.__call__(None, instance=self.datafiles[0]) # Check a parameter set was created for the datafile datafile = Dataset_File.objects.get(id=self.datafiles[0].id) expect(datafile.getParameterSets().count()).to_equal(1) # Check that at least the verion number was extracted psm = ParameterSetManager(datafile.getParameterSets()[0]) expect(psm.get_param('softmax_version', True)).to_equal('5.42.1.0') # Check we won't create a duplicate datafile filter = FlexstationFilter("Flexstation Test Schema", "http://rmit.edu.au/flexstation_test") filter.__call__(None, instance=self.datafiles[0]) datafile = Dataset_File.objects.get(id=self.datafiles[0].id) expect(datafile.getParameterSets().count()).to_equal(1)
def testFlexstationAllFields(self): """ Simple test running the filter and making sure the Softmax version number was saved """ filter = FlexstationFilter("Flexstation Test Schema", "http://rmit.edu.au/flexstation_test") filter.__call__(None, instance=self.datafiles[0]) # Check a parameter set was created for the datafile datafile = Dataset_File.objects.get(id=self.datafiles[0].id) expect(datafile.getParameterSets().count()).to_equal(1) # Check all the expected parameters are there psm = ParameterSetManager(datafile.getParameterSets()[0]) expect(psm.get_param('softmax_version', True)).to_equal('5.42.1.0') expect(psm.get_param('experiment_name', True)).to_equal('Experiment#1') expect(psm.get_param('analysis_notes', True)).to_equal( u'Notes#1: TRPV1 Phosphate mutants\rCells seeded 48hrs prior 40K cel/well \rInduced with tetracycline for 3 hrs washed once with hepes (50microL/well) then loaded with fura2 for 1 hr (50 microL/well). then washed twice with 60microl or HEPES buffer per well finaly loaded with 60microl of hepes.\rCells:\rcolumn 1: Nt, 2: WtV1, 3: C1, 4: C2, 5: C3, 6: C4, 7: C5, 8: N1, 9: N6\rinjection 1: rows A-D buffer only, E-H 100microM SLIGRL\rinjection 2: Row A,E DMSO 1%, B,F 1microM CAPS, C,G 10microM CAPS, D,H 100microM caps' ) expect(psm.get_param( 'instrument_info', True)).to_equal('Flexstation III ROM v2.1.35 20May09') #expect(psm.get_param('plate_read_time', True)).to_equal('') #expect(psm.get_param('read_type', True)).to_equal('') #expect(psm.get_param('data_mode', True)).to_equal('') #expect(psm.get_param('data_type', True)).to_equal('') expect(psm.get_param('strips', True)).to_equal('1-9') expect(psm.get_param('trans', True)).to_equal( u'Trans1: H=80\xb5, R=4, V=20.0\xb5, \x4015. Trans2: H=100\xb5, R=4, V=20.0\xb5, \x40115' ) expect(psm.get_param('kinetic_points', True)).to_equal(65.0) expect(psm.get_param('kinetic_flex_read_time', True)).to_equal(250.0) expect(psm.get_param('kinetic_flex_interval', True)).to_equal(3.9) expect(psm.get_param('number_of_wavelengths', True)).to_equal(2) expect(psm.get_param('read_wavelength', True)).to_equal('520 520') expect(psm.get_param('number_of_wells_or_cuvette', True)).to_equal(96.0) expect(psm.get_param('excitation_wavelengths', True)).to_equal('340 380')
def testFlexstationTwoExperimentsInFile(self): """ Simple test running the filter and making sure the Softmax version number was saved """ filter = FlexstationFilter("Flexstation Test Schema", "http://rmit.edu.au/flexstation_test") filter.__call__(None, instance=self.datafiles[5]) # Check a parameter set was created for the datafile datafile = Dataset_File.objects.get(id=self.datafiles[5].id) expect(datafile.getParameterSets().count()).to_equal(1) # Check all the expected parameters are there psm = ParameterSetManager(datafile.getParameterSets()[0]) expect(psm.get_param('softmax_version', True)).to_equal('5.4.52.1.0') expect(psm.get_param('experiment_name', True)).to_equal('Exp01') expect(psm.get_param('analysis_notes', True)).to_equal( u'Revision_101: PROTOCOL REVISION HISTORY:\rv1.0.0: original protocol created (MDC)\rv1.0.1: 06/30/05 - Updated, spell checked, & formatted to new style guide. (DW)\r\rREADER SUITABILITY:\r\nEMax, VMax, ThermoMax, VersaMax, SpectraMax, SpectraMax Plus, SpectraMax Plus 384, SpectraMax 190, SpectraMax 340PC, SpectraMax 340PC 384, SpectraMax M2, SpectraMax M5. Intro: MIPS resupply 3759, 3720 latin square\rcells seeded 48hrs prior using FTA. Cells were 95-100% confluent on the day of the experiment.\rColumns 1,3,5,7,9,11 are non-transfected HEK cells, columns 2,4,6,8,10,12 are hTRPV4 HEK.\rCells were induced the evening prior to assay with 0.1\xb5g/ml tet \rLoaded with FURA-2 at 805 Inhibitor at 900\rLatin square\r 1 2 3 4 5 6 \ra x x x x x x\rb c z y x w v \rc v c z y x w\rd w v c z y x\re x w v c z y\rf y x w v c z\rg z y x w v c\rh x x x x x x\rc control V vehicle 0.1% DMSO, w 3759 10\xb5M x 3759 1\xb5M y 3720 10\xb5M z 3720 1\xb5M\rInjection 1 at 15"\rSLIGRL 30\xb5M\rInjection 2 at 80" \rGSK 30nM ' ) expect(psm.get_param( 'instrument_info', True)).to_equal('Flexstation III ROM v3.0.22 16Feb11') #expect(psm.get_param('plate_read_time', True)).to_equal('') #expect(psm.get_param('read_type', True)).to_equal('') #expect(psm.get_param('data_mode', True)).to_equal('') #expect(psm.get_param('data_type', True)).to_equal('') expect(psm.get_param('strips', True)).to_equal('1-12') expect(psm.get_param('trans', True)).to_equal( u'Trans1: H=80\xb5, R=4, V=20.0\xb5, \x4015. Trans2: H=100\xb5, R=4, V=25.0\xb5, \x4080' ) expect(psm.get_param('kinetic_points', True)).to_equal(39.0) expect(psm.get_param('kinetic_flex_read_time', True)).to_equal(150.0) expect(psm.get_param('kinetic_flex_interval', True)).to_equal(3.9) expect(psm.get_param('number_of_wavelengths', True)).to_equal(2) expect(psm.get_param('read_wavelength', True)).to_equal('520 520') expect(psm.get_param('number_of_wells_or_cuvette', True)).to_equal(96.0) expect(psm.get_param('excitation_wavelengths', True)).to_equal('340 380')
def get_filename(ps): try: return ParameterSetManager(ps)\ .get_param('metadata-filename', True) except DatasetParameter.DoesNotExist: return None
def get_subject(ps, type_): psm = ParameterSetManager(ps) return { 'text': psm.get_param('code', True), 'type': type_ }