def save_rif_cs_profile(self, experiment, profile): """ Save selected profile choice as experiment parameter """ namespace = "http://monash.edu.au/rif-cs/profile/" schema = None try: schema = Schema.objects.get(namespace__exact=namespace) except Schema.DoesNotExist: logger.debug('Schema ' + namespace + ' does not exist. Creating.') schema = Schema(namespace=namespace) schema.save() try: parametername = ParameterName.objects.get( schema__namespace__exact=schema.namespace, name="profile") except ParameterName.DoesNotExist: logger.debug("profile does not exist. Creating.") parametername = ParameterName(name="profile", schema=schema) parametername.save() parameterset = None try: parameterset = \ ExperimentParameterSet.objects.get(\ schema=schema, experiment=experiment) except ExperimentParameterSet.DoesNotExist, e: parameterset = ExperimentParameterSet(\ schema=schema, experiment=experiment) parameterset.save()
def test_instrument(self): group = Group(name="Test Manager Group") group.save() facility = Facility(name="Test Facility", manager_group=group) facility.save() self.assertEqual(str(facility), "Test Facility") instrument = Instrument(name="Test Instrument", facility=facility) instrument.save() self.assertEqual(str(instrument), "Test Instrument") self.assertEqual(len(instrument.getParameterSets()), 0) schema = Schema(namespace='test instrument schema namespace', type=Schema.INSTRUMENT) schema.save() parname = ParameterName(schema=schema, name='name', full_name='full_name') parname.save() pset = InstrumentParameterSet.objects.create(instrument=instrument, schema=schema) pset.save() self.assertEqual(len(instrument.getParameterSets()), 1)
def save_rif_cs_profile(self, experiment, profile): """ Save selected profile choice as experiment parameter """ namespace = "http://monash.edu.au/rif-cs/profile/" schema = None try: schema = Schema.objects.get( namespace__exact=namespace) except Schema.DoesNotExist: logger.debug('Schema ' + namespace + ' does not exist. Creating.') schema = Schema(namespace=namespace) schema.save() parametername = ParameterName.objects.get( schema__namespace__exact=schema.namespace, name="profile") parameterset = None try: parameterset = \ ExperimentParameterSet.objects.get(\ schema=schema, experiment=experiment) except ExperimentParameterSet.DoesNotExist, e: parameterset = ExperimentParameterSet(\ schema=schema, experiment=experiment) parameterset.save()
def get_schema(schema, name): """Return the schema object that the paramaterset will use. """ try: return Schema.objects.get(namespace__exact=schema) except Schema.DoesNotExist: schema = Schema(namespace=schema, name=name, type=Schema.DATASET) schema.save() return schema
def getSchema(self): """Returns the schema object that the parameter set will use. """ try: return Schema.objects.get(namespace__exact=self.schema) except Schema.DoesNotExist: schema = Schema(namespace=self.schema, name=self.name, type=Schema.DATAFILE) schema.save() return schema
def get_schema(self): try: schema = Schema.objects.get(namespace=self.namespace) except ObjectDoesNotExist: schema = Schema() schema.namespace = self.namespace schema.save() self.schema = schema return schema
def get_schema(self): try: schema = Schema.objects.get( namespace=self.namespace) except ObjectDoesNotExist: schema = Schema() schema.namespace = self.namespace schema.save() self.schema = schema return schema
def getSchema(self): """Return the schema object that the paramaterset will use. """ try: return Schema.objects.get(namespace__exact=self.schema) except Schema.DoesNotExist: schema = Schema(namespace=self.schema, name=self.name, type=Schema.DATAFILE) schema.save() return schema
def get_schema(self): from tardis.tardis_portal.models import Schema try: schema = Schema.objects.get(namespace=self.namespace) except ObjectDoesNotExist: schema = Schema() schema.namespace = self.namespace schema.save() self.schema = schema return schema
def getSchema(self): """Return the schema object that the paramaterset will use. """ logger.error('Olympus-getSchema()') try: return Schema.objects.get(namespace__exact=self.schema) except Schema.DoesNotExist: schema = Schema(namespace=self.schema, name=self.name, type=Schema.DATAFILE) schema.save() return schema
def get_schema(self): from tardis.tardis_portal.models import Schema try: schema = Schema.objects.get( namespace=self.namespace) except ObjectDoesNotExist: schema = Schema() schema.namespace = self.namespace schema.save() self.schema = schema return schema
def _get_schema(schema, name): """Return the schema object that the paramaterset will use. """ try: sch = Schema.objects.get(namespace__exact=schema) logger.debug("found %s %s" % (sch.namespace, sch.name)) return sch except Schema.DoesNotExist: schema = Schema(namespace=schema, name=name, type=Schema.DATASET) schema.save() logger.debug("creating %s %s " % (schema, name)) return schema
def setUp(self): # Load schemas for test from django.core.management import call_command call_command('loaddata', 'as_schemas') self.client = Client() self.experiments = [] try: user = User.objects.get(username='******') except User.DoesNotExist: user = User.objects.create_user('test', '', 'test') user.save() self.userprofile = user.userprofile # base_path = path.abspath(path.dirname(__file__)) experiment = Experiment(title='SAXS Test', created_by=user) experiment.save() acl = ObjectACL(pluginId=django_user, entityId=str(user.id), content_object=experiment, canRead=True, canWrite=True, canDelete=True, isOwner=True) acl.save() self.experiments += [experiment] schema = Schema.objects.get(type=Schema.DATAFILE, subtype='saxs') parameter = ParameterName.objects.get(schema=schema, name='io') parameter.is_searchable = True parameter.save() self.io_param_name = parameter.getUniqueShortName() schema = Schema.objects.get(type=Schema.DATASET, subtype='saxs') parameter = ParameterName.objects.get(schema=schema, name='frqimn') parameter.is_searchable = True parameter.save() self.frqimn_param_name = parameter.getUniqueShortName() new_schema = Schema() new_schema.namespace = 'testschemawithduplicatename' new_schema.save() new_param = ParameterName( schema=new_schema, name='title', full_name='Duplicate title parametername', is_searchable=True) new_param.save()
def _get_schema(schema,name): """Return the schema object that the paramaterset will use. """ try: sch = Schema.objects.get(namespace__exact=schema) logger.debug("found %s %s" % (sch.namespace, sch.name)) return sch except Schema.DoesNotExist: schema = Schema(namespace=schema, name=name, type=Schema.DATASET) schema.save() logger.debug("creating %s %s " % (schema,name)) return schema
def getSchema(self): return Schema.objects.get(namespace='http://cai.uq.edu.au/schema/metadata/1') # FIXME Ignoring this stuff... why would we dynamically create a Schema here? """Return the schema object that the paramaterset will use. """ try: return Schema.objects.get(namespace__exact=self.schema) except Schema.DoesNotExist: schema = Schema(namespace=self.schema, name=self.name, type=Schema.DATAFILE) schema.save() return schema
def test_contextual_view(self): """ Given schema on dataset, check that image file created """ user = _create_test_user() license = _create_license() exp = _create_test_experiment(user, license) ds = Dataset(description='happy snaps of plumage') ds.save() ds = _create_test_dataset( ds, exp.id, { "output.dat": 'test data\n', "grexp.dat": '1 2\n2 3\n3 7\n', "grfinal21.dat": '1 2\n 2 4\n4 9\n' }) sch = Schema(namespace=self.HRMCSCHEMA, name="hrmc_views", type=Schema.DATASET) sch.save() param = ParameterName(schema=sch, name="plot", full_name="scatterplot", units="image", data_type=ParameterName.FILENAME) param.save() dps = DatasetParameterSet(schema=sch, dataset=ds) dps.save() ds.experiments.add(exp) ds.save() client = Client() response = client.get('/dataset/%s' % ds.id) self.assertEqual(response.status_code, 200) param_sets = get_param_sets(ds) self.assertTrue(param_sets) dp = DatasetParameter.objects.get(parameterset=param_sets[0], name=param) self.assertTrue(dp) self.assertNotEquals(dp.string_value, "") # ie, it has a filename
def _save_party_refs(self, party, party_relation): """ Save party and party relation information as parameters on the experiment """ namespace = "http://rmit.edu.au/rif-cs/party/1.0/" logger.debug("saving party") schema = None try: schema = Schema.objects.get( namespace__exact=namespace) except Schema.DoesNotExist: logger.debug('Schema ' + namespace + ' does not exist. Creating.') schema = Schema(namespace=namespace) schema.save() exp = Experiment.objects.get(pk=self.experiment_id) party_id_param = self._make_param(schema=schema, name="party_id", paramtype=ParameterName.NUMERIC) relation_param = self._make_param(schema=schema, name="relationtocollection_id", paramtype=ParameterName.STRING) parameterset = ExperimentParameterSet(schema=schema, experiment=exp) parameterset.save() ep = ExperimentParameter.objects.filter(name=party_id_param, parameterset=parameterset, parameterset__experiment=exp) for p in ep: p.delete() ep = ExperimentParameter( parameterset=parameterset, name=party_id_param, numerical_value=party.pk) ep.save() ep = ExperimentParameter.objects.filter(name=relation_param, parameterset=parameterset, parameterset__experiment=exp) for p in ep: p.delete() ep = ExperimentParameter( parameterset=parameterset, name=relation_param, string_value=party_relation) ep.save()
def test_hrmc_filter(self): """ Make an experiment, lood up grexp file and check dataset schema missing, then loadup grfinal and check dataset schema created """ user = _create_test_user() license = _create_license() exp = _create_test_experiment(user, license) ds = Dataset(description='happy snaps of plumage') ds.save() _create_test_dataset(ds, exp.id, { "output.dat": 'hello', "grexp.dat": '2 5\n6 15\n' }) ds.experiments.add(exp) ds.save() sch = Schema(namespace=self.HRMCSCHEMA, name="hrmc_views", type=Schema.DATASET) sch.save() param = ParameterName(schema=sch, name="plot", full_name="scatterplot", units="image", data_type=ParameterName.FILENAME) param.save() param_sets = get_param_sets(ds) self.assertEquals(list(param_sets), []) _create_test_dataset(ds, exp.id, {'grfinal21.dat': "1 3\n5 14\n"}) df2 = Dataset_File(dataset=ds, url='path/grfinal21.dat') df2.save() h = hrmc.HRMCOutput('HRMC', self.HRMCSCHEMA) h(sender=Dataset_File, instance=df2) param_sets = get_param_sets(ds) self.assertEquals([x.schema.namespace for x in param_sets], [self.HRMCSCHEMA])
def test_contextual_view(self): """ Given schema on dataset, check that image file created """ user = _create_test_user() license = _create_license() exp = _create_test_experiment(user, license) ds = Dataset(description='happy snaps of plumage') ds.save() ds = _create_test_dataset(ds, exp.id, { "output.dat": 'test data\n', "grexp.dat": '1 2\n2 3\n3 7\n', "grfinal21.dat": '1 2\n 2 4\n4 9\n'}) sch = Schema(namespace=self.HRMCSCHEMA, name="hrmc_views", type=Schema.DATASET) sch.save() param = ParameterName(schema=sch, name="plot", full_name="scatterplot", units="image", data_type=ParameterName.FILENAME ) param.save() dps = DatasetParameterSet(schema=sch, dataset=ds) dps.save() ds.experiments.add(exp) ds.save() client = Client() response = client.get('/dataset/%s' % ds.id) self.assertEqual(response.status_code, 200) param_sets = get_param_sets(ds) self.assertTrue(param_sets) dp = DatasetParameter.objects.get(parameterset=param_sets[0], name=param) self.assertTrue(dp) self.assertNotEquals(dp.string_value, "") # ie, it has a filename
def test_hrmc_filter(self): """ Make an experiment, lood up grexp file and check dataset schema missing, then loadup grfinal and check dataset schema created """ user = _create_test_user() license = _create_license() exp = _create_test_experiment(user, license) ds = Dataset(description='happy snaps of plumage') ds.save() _create_test_dataset(ds, exp.id, {"output.dat": 'hello', "grexp.dat": '2 5\n6 15\n'}) ds.experiments.add(exp) ds.save() sch = Schema(namespace=self.HRMCSCHEMA, name="hrmc_views", type=Schema.DATASET) sch.save() param = ParameterName(schema=sch, name="plot", full_name="scatterplot", units="image", data_type=ParameterName.FILENAME ) param.save() param_sets = get_param_sets(ds) self.assertEquals(list(param_sets), []) _create_test_dataset(ds, exp.id, {'grfinal21.dat': "1 3\n5 14\n"}) df2 = Dataset_File(dataset=ds, url='path/grfinal21.dat') df2.save() h = hrmc.HRMCOutput('HRMC', self.HRMCSCHEMA) h(sender=Dataset_File, instance=df2) param_sets = get_param_sets(ds) self.assertEquals([x.schema.namespace for x in param_sets], [self.HRMCSCHEMA])
def _save_party_refs(self, party, party_relation): """ Save party and party relation information as parameters on the experiment """ namespace = "http://rmit.edu.au/rif-cs/party/1.0/" logger.debug("saving party") schema = None try: schema = Schema.objects.get(namespace__exact=namespace) except Schema.DoesNotExist: logger.debug('Schema ' + namespace + ' does not exist. Creating.') schema = Schema(namespace=namespace) schema.save() exp = Experiment.objects.get(pk=self.experiment_id) party_id_param = self._make_param(schema=schema, name="party_id", paramtype=ParameterName.NUMERIC) relation_param = self._make_param(schema=schema, name="relationtocollection_id", paramtype=ParameterName.STRING) parameterset = ExperimentParameterSet(schema=schema, experiment=exp) parameterset.save() ep = ExperimentParameter.objects.filter(name=party_id_param, parameterset=parameterset, parameterset__experiment=exp) for p in ep: p.delete() ep = ExperimentParameter(parameterset=parameterset, name=party_id_param, numerical_value=party.pk) ep.save() ep = ExperimentParameter.objects.filter(name=relation_param, parameterset=parameterset, parameterset__experiment=exp) for p in ep: p.delete() ep = ExperimentParameter(parameterset=parameterset, name=relation_param, string_value=party_relation) ep.save()
class ParameterSetManagerTestCase(TestCase): def setUp(self): from django.contrib.auth.models import User from tempfile import mkdtemp user = '******' pwd = 'secret' email = '' self.user = User.objects.create_user(user, email, pwd) self.test_dir = mkdtemp() self.exp = Experiment(title='test exp1', institution_name='monash', created_by=self.user) self.exp.save() self.dataset = Dataset(description="dataset description...") self.dataset.save() self.dataset.experiments.add(self.exp) self.dataset.save() self.datafile = DataFile(dataset=self.dataset, filename="testfile.txt", size="42", md5sum='bogus') self.datafile.save() self.dfo = DataFileObject( datafile=self.datafile, storage_box=self.datafile.get_default_storage_box(), uri="1/testfile.txt") self.dfo.save() self.schema = Schema(namespace="http://localhost/psmtest/df/", name="Parameter Set Manager", type=3) self.schema.save() self.parametername1 = ParameterName(schema=self.schema, name="parameter1", full_name="Parameter 1") self.parametername1.save() self.parametername2 = ParameterName(schema=self.schema, name="parameter2", full_name="Parameter 2", data_type=ParameterName.NUMERIC) self.parametername2.save() self.parametername3 = ParameterName(schema=self.schema, name="parameter3", full_name="Parameter 3", data_type=ParameterName.DATETIME) self.parametername3.save() self.datafileparameterset = DatafileParameterSet( schema=self.schema, datafile=self.datafile) self.datafileparameterset.save() self.datafileparameter1 = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername1, string_value="test1") self.datafileparameter1.save() self.datafileparameter2 = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername2, numerical_value=2) self.datafileparameter2.save() # Create a ParameterName and Parameter of type LINK to an experiment self.parametername_exp_link = ParameterName( schema=self.schema, name="exp_link", full_name="This parameter is a experiment LINK", data_type=ParameterName.LINK) self.parametername_exp_link.save() self.exp_link_param = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername_exp_link) exp_url = self.exp.get_absolute_url() # /experiment/view/1/ self.exp_link_param.set_value(exp_url) self.exp_link_param.save() # Create a ParameterName and Parameter of type LINK to a dataset self.parametername_dataset_link = ParameterName( schema=self.schema, name="dataset_link", full_name="This parameter is a dataset LINK", data_type=ParameterName.LINK) self.parametername_dataset_link.save() self.dataset_link_param = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername_dataset_link) dataset_url = self.dataset.get_absolute_url() # /dataset/1/ self.dataset_link_param.set_value(dataset_url) self.dataset_link_param.save() # Create a ParameterName type LINK to an unresolvable (non-URL) # free-text value self.parametername_unresolvable_link = ParameterName( schema=self.schema, name="freetext_link", full_name="This parameter is a non-URL LINK", data_type=ParameterName.LINK) self.parametername_unresolvable_link.save() def tearDown(self): self.exp.delete() self.user.delete() self.parametername1.delete() self.parametername2.delete() self.parametername3.delete() self.parametername_exp_link.delete() self.parametername_dataset_link.delete() self.parametername_unresolvable_link.delete() self.schema.delete() 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_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 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_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 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 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", str(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 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))
class ParameterSetManagerTestCase(TestCase): def setUp(self): from django.contrib.auth.models import User from tempfile import mkdtemp user = '******' pwd = 'secret' email = '' self.user = User.objects.create_user(user, email, pwd) self.test_dir = mkdtemp() self.exp = Experiment(title='test exp1', institution_name='monash', created_by=self.user) self.exp.save() self.dataset = Dataset(description="dataset description...") self.dataset.save() self.dataset.experiments.add(self.exp) self.dataset.save() self.datafile = DataFile(dataset=self.dataset, filename="testfile.txt", size="42", md5sum='bogus') self.datafile.save() self.dfo = DataFileObject( datafile=self.datafile, storage_box=self.datafile.get_default_storage_box(), uri="1/testfile.txt") self.dfo.save() self.schema = Schema( namespace="http://localhost/psmtest/df/", name="Parameter Set Manager", type=3) self.schema.save() self.parametername1 = ParameterName( schema=self.schema, name="parameter1", full_name="Parameter 1") self.parametername1.save() self.parametername2 = ParameterName( schema=self.schema, name="parameter2", full_name="Parameter 2", data_type=ParameterName.NUMERIC) self.parametername2.save() self.parametername3 = ParameterName( schema=self.schema, name="parameter3", full_name="Parameter 3", data_type=ParameterName.DATETIME) self.parametername3.save() self.datafileparameterset = DatafileParameterSet( schema=self.schema, datafile=self.datafile) self.datafileparameterset.save() self.datafileparameter1 = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername1, string_value="test1") self.datafileparameter1.save() self.datafileparameter2 = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername2, numerical_value=2) self.datafileparameter2.save() # Create a ParameterName and Parameter of type LINK to an experiment self.parametername_exp_link = ParameterName( schema=self.schema, name="exp_link", full_name="This parameter is a experiment LINK", data_type=ParameterName.LINK) self.parametername_exp_link.save() self.exp_link_param = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername_exp_link) exp_url = self.exp.get_absolute_url() # /experiment/view/1/ self.exp_link_param.set_value(exp_url) self.exp_link_param.save() # Create a ParameterName and Parameter of type LINK to a dataset self.parametername_dataset_link = ParameterName( schema=self.schema, name="dataset_link", full_name="This parameter is a dataset LINK", data_type=ParameterName.LINK) self.parametername_dataset_link.save() self.dataset_link_param = DatafileParameter( parameterset=self.datafileparameterset, name=self.parametername_dataset_link) dataset_url = self.dataset.get_absolute_url() # /dataset/1/ self.dataset_link_param.set_value(dataset_url) self.dataset_link_param.save() # Create a ParameterName type LINK to an unresolvable (non-URL) # free-text value self.parametername_unresolvable_link = ParameterName( schema=self.schema, name="freetext_link", full_name="This parameter is a non-URL LINK", data_type=ParameterName.LINK) self.parametername_unresolvable_link.save() def tearDown(self): self.exp.delete() self.user.delete() self.parametername1.delete() self.parametername2.delete() self.parametername3.delete() self.parametername_exp_link.delete() self.parametername_dataset_link.delete() self.parametername_unresolvable_link.delete() self.schema.delete() 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_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 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_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 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 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", str(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 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 test_parameter(self): exp = Experiment( title='test exp1', institution_name='Australian Synchrotron', approved=True, created_by=self.user, public_access=Experiment.PUBLIC_ACCESS_NONE, ) exp.save() dataset = Dataset(description="dataset description") dataset.save() dataset.experiments.add(exp) dataset.save() df_file = DataFile(dataset=dataset, filename='file.txt', size=42, md5sum='bogus') df_file.save() df_schema = Schema(namespace='http://www.cern.ch/felzmann/schema1.xml', type=Schema.DATAFILE) df_schema.save() ds_schema = Schema(namespace='http://www.cern.ch/felzmann/schema2.xml', type=Schema.DATASET) ds_schema.save() exp_schema = Schema( namespace='http://www.cern.ch/felzmann/schema3.xml', type=Schema.EXPERIMENT) exp_schema.save() df_parname = ParameterName(schema=df_schema, name='name', full_name='full_name', units='image/jpg', data_type=ParameterName.FILENAME) df_parname.save() ds_parname = ParameterName(schema=ds_schema, name='name', full_name='full_name', units='image/jpg', data_type=ParameterName.FILENAME) ds_parname.save() exp_parname = ParameterName(schema=exp_schema, name='name', full_name='full_name', units='image/jpg', data_type=ParameterName.FILENAME) exp_parname.save() df_parset = DatafileParameterSet(schema=df_schema, datafile=df_file) df_parset.save() ds_parset = DatasetParameterSet(schema=ds_schema, dataset=dataset) ds_parset.save() exp_parset = ExperimentParameterSet(schema=exp_schema, experiment=exp) exp_parset.save() with self.settings(METADATA_STORE_PATH=os.path.dirname(__file__)): filename = 'test.jpg' df_parameter = DatafileParameter(name=df_parname, parameterset=df_parset, string_value=filename) df_parameter.save() ds_parameter = DatasetParameter(name=ds_parname, parameterset=ds_parset, string_value=filename) ds_parameter.save() exp_parameter = ExperimentParameter(name=exp_parname, parameterset=exp_parset, string_value=filename) exp_parameter.save() self.assertEqual( "<a href='/display/DatafileImage/load/%i/' target='_blank'><img style='width: 300px;' src='/display/DatafileImage/load/%i/' /></a>" % # noqa (df_parameter.id, df_parameter.id), df_parameter.get()) self.assertEqual( "<a href='/display/DatasetImage/load/%i/' target='_blank'><img style='width: 300px;' src='/display/DatasetImage/load/%i/' /></a>" % # noqa (ds_parameter.id, ds_parameter.id), ds_parameter.get()) self.assertEqual( "<a href='/display/ExperimentImage/load/%i/' target='_blank'><img style='width: 300px;' src='/display/ExperimentImage/load/%i/' /></a>" % # noqa (exp_parameter.id, exp_parameter.id), exp_parameter.get())
def __call__(self, sender, **kwargs): """post save callback entry point. :param sender: The model class. :param instance: The actual instance being saved. :param created: A boolean; True if a new record was created. :type created: bool """ instance = kwargs.get('instance') created = kwargs.get('created') if not created: # Don't extract on edit return # schema = self.getSchema() filepath = instance.get_absolute_filepath() if not filepath: # TODO log that exited early return # generate thumbnails for image file try: img = Image.open(filepath) write_thumbnails(instance, img) except IOError: # file not an image file pass # ignore non-image file if filepath[-4:].lower() != ".tif": return # Find instrument name in filepath instr_name = None import re pathSep = re.compile(r'\\|\/') for part in pathSep.split(filepath): if part in self.instruments.keys(): instr_name = part logger.debug("filepath=%s" % filepath) logger.debug("instr_name=%s" % instr_name) if (instr_name != None and len(instr_name) > 1): logger.debug("instr_name %s" % instr_name) exifs = self.getExif(filepath) for exifTag in exifs: logger.debug("exifTag=%s" % exifTag) if exifTag == 'Image Tag 0x877A' or exifTag == 'Image Tag 0x8778': tmpfile = "/tmp/workfile_%s" % random.randint(1, 9999) f = open(tmpfile, 'w') f.write(exifs[exifTag]) f.close() x877a_tags = ConfigParser.RawConfigParser() x877a_tags.read(tmpfile) instrSchemas = self.instruments[instr_name] # for each schema for this instrument for sch in instrSchemas: (schemaName,schemaSuffix,tagsToFind) = sch logger.debug("schemaTuple %s = %s %s %s" %(sch,schemaName,schemaSuffix,tagsToFind)) # find values in tags metadata = {} detector_name = "" pixel_width = 0 for tag in tagsToFind: (section, option, fieldname, unit, multiplier) = tag try: # get values in detector section if section == "Detector_Name" and detector_name != "": section = detector_name value = x877a_tags.get(section, option) # convert value with specified multiplier if multiplier: value = float(value) * multiplier # round values if option in ["WorkingDistance", "Contrast", "Brightness"]: value = round(float(value), 1) if option in ["Magnification"]: value = int(round(float(value))) # get Chamber Pressure if section == "Vacuum" and option.lower() == "chpressure": value_in_torr = float(value) / 133.322368 value_in_mbar = float(value) / 100 value = "%.4G Torr (%.4G mbar)" % (value_in_torr, value_in_mbar) # get metadata metadata["[%s] %s" % (section, fieldname)] = [value, unit] # get Detector Name if section == "Detectors" and option == "Name": detector_name = value # get Pixel Width for calculating magnification if section == "Scan" and option == "PixelWidth": pixel_width = float(value) except ConfigParser.NoSectionError: pass # Calculate Magnification if pixel_width and instr_name in ["Quanta200", "NovaNanoSEM"]: section = "Scan" option = "Original Magnification (Full Screen)" if instr_name == "Quanta200": monitor_pixel_width = 0.00025 if instr_name == "NovaNanoSEM": monitor_pixel_width = 0.000291406 value = round( monitor_pixel_width / pixel_width ) unit = "X" # get metadata metadata["[%s] %s" % (section, option)] = [value, unit] # only save exif data if we found some expected metadata logger.debug("metadata = %s" % metadata) if len(metadata) > 0: # Make instrument specific schema instrNamespace = ''.join([self.schema, "/" , schemaSuffix]) # create schema if needed try: schema = Schema.objects.get(namespace__exact=instrNamespace) logger.debug("found existing metadata schema %s" % schema) except Schema.DoesNotExist: schema = Schema(namespace=instrNamespace, name=schemaName,type=Schema.DATAFILE) logger.debug("creating new metadata schema %s" % schema) schema.save() # and save metadata ps = self.saveExifMetadata(instance, schema, metadata) logger.debug("ps=%s" % ps) os.remove(tmpfile)
class ContextualViewTest(TestCase): def setUp(self): """ setting up essential objects, copied from tests above """ user = '******' pwd = 'secret' email = '' self.user = User.objects.create_user(user, email, pwd) self.userProfile = self.user.userprofile self.exp = Experiment(title='test exp1', institution_name='monash', created_by=self.user) self.exp.save() self.acl = ObjectACL( pluginId=django_user, entityId=str(self.user.id), content_object=self.exp, canRead=True, isOwner=True, aclOwnershipType=ObjectACL.OWNER_OWNED, ) self.acl.save() self.dataset = Dataset(description='dataset description...') self.dataset.save() self.dataset.experiments.add(self.exp) self.dataset.save() self.datafile = DataFile(dataset=self.dataset, size=42, filename="foo", md5sum="junk") self.datafile.save() self.testschema = Schema(namespace="http://test.com/test/schema", name="Test View", type=Schema.DATAFILE, hidden=True) self.testschema.save() self.dfps = DatafileParameterSet(datafile=self.datafile, schema=self.testschema) self.dfps.save() def tearDown(self): self.user.delete() self.exp.delete() self.dataset.delete() self.datafile.delete() self.testschema.delete() self.dfps.delete() self.acl.delete() def testDetailsDisplay(self): """ test display of view for an existing schema and no display for an undefined one. """ from tardis.tardis_portal.views import display_datafile_details request = flexmock(user=self.user, groups=[("testgroup", flexmock())]) with self.settings(DATAFILE_VIEWS=[( "http://test.com/test/schema", "/test/url"), ("http://does.not.exist", "/false/url")]): response = display_datafile_details(request, datafile_id=self.datafile.id) self.assertEqual(response.status_code, 200) self.assertTrue("/ajax/parameters/" in response.content) self.assertTrue("/test/url" in response.content) self.assertFalse("/false/url" in response.content)
class ContextualViewTest(TestCase): def setUp(self): """ setting up essential objects, copied from tests above """ user = '******' pwd = 'secret' email = '' self.user = User.objects.create_user(user, email, pwd) self.userProfile = UserProfile(user=self.user).save() self.exp = Experiment(title='test exp1', institution_name='monash', created_by=self.user) self.exp.save() self.acl = ObjectACL( pluginId=django_user, entityId=str(self.user.id), content_object=self.exp, canRead=True, isOwner=True, aclOwnershipType=ObjectACL.OWNER_OWNED, ) self.acl.save() self.dataset = Dataset(description='dataset description...') self.dataset.save() self.dataset.experiments.add(self.exp) self.dataset.save() self.dataset_file = Dataset_File(dataset=self.dataset, size=42, filename="foo", md5sum="junk") self.dataset_file.save() self.testschema = Schema(namespace="http://test.com/test/schema", name="Test View", type=Schema.DATAFILE, hidden=True) self.testschema.save() self.dfps = DatafileParameterSet(dataset_file=self.dataset_file, schema=self.testschema) self.dfps.save() def tearDown(self): self.user.delete() self.exp.delete() self.dataset.delete() self.dataset_file.delete() self.testschema.delete() self.dfps.delete() self.acl.delete() def testDetailsDisplay(self): """ test display of view for an existing schema and no display for an undefined one. """ from tardis.tardis_portal.views import display_datafile_details request = flexmock(user=self.user, groups=[("testgroup",flexmock())]) with self.settings(DATAFILE_VIEWS=[("http://test.com/test/schema", "/test/url"), ("http://does.not.exist", "/false/url")]): response = display_datafile_details(request, dataset_file_id=self.dataset_file.id) self.assertEqual(response.status_code, 200) self.assertTrue("/ajax/parameters/" in response.content) self.assertTrue("/test/url" in response.content) self.assertFalse("/false/url" in response.content)