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_ }
