def test_invalid_assignment():
"""Test that invalid assignment throws a TypeError."""
with pytest.raises(TypeError):
PropertyAndConditions(property=LinkByUID('id', 'a15'))
with pytest.raises(TypeError):
PropertyAndConditions(
property=Property("property"),
conditions=[Condition("condition"),
LinkByUID('scope', 'id')])
def test_material_spec():
"""Test that Process/Material Spec link survives serialization."""
# Create a ProcessSpec
proc_spec = ProcessSpec(name="a process spec", tags=["tag1", "tag2"])
# Create MaterialSpec without a ProcessSpec
prop = Property(
name="The material is a solid",
value=DiscreteCategorical(probabilities="solid")
)
mat_spec = MaterialSpec(name="a material spec", properties=PropertyAndConditions(prop))
assert mat_spec.process is None, \
"MaterialSpec should be initialized with no ProcessSpec, by default"
# Assign a ProcessSpec to mat_spec, first ensuring that the type is enforced
with pytest.raises(TypeError):
mat_spec.process = 17
mat_spec.process = proc_spec
# Assert circular links
assert dumps(proc_spec.output_material.process) == dumps(proc_spec), \
"ProcessSpec should link to MaterialSpec that links back to itself"
assert dumps(mat_spec.process.output_material) == dumps(mat_spec), \
"MaterialSpec should link to ProcessSpec that links back to itself"
# Make copies of both specs
mat_spec_copy = loads(dumps(mat_spec))
proc_spec_copy = loads(dumps(proc_spec))
assert proc_spec_copy.output_material == mat_spec, \
"Serialization should preserve link from ProcessSpec to MaterialSpec"
assert mat_spec_copy.process == proc_spec, \
"Serialization should preserve link from MaterialSpec to ProcessSpec"
def test_material_run():
"""
Test the ability to create a MaterialRun that is linked to a MaterialSpec.
Make sure all enumerated values are respected, and check consistency after
serializing and deserializing.
"""
# Define a property, and make sure that an inappropriate value for origin throws ValueError
with pytest.raises(ValueError):
prop = Property(name="A property",
origin="bad origin",
value=NominalReal(17, units=''))
# Create a MaterialSpec with a property
prop = Property(name="A property",
origin="specified",
value=NominalReal(17, units=''))
mat_spec = MaterialSpec(name="a specification for a material",
properties=PropertyAndConditions(prop),
notes="Funny lookin'")
# Make sure that when property is serialized, origin (an enumeration) is serialized as a string
copy_prop = json.loads(dumps(mat_spec))
copy_origin = copy_prop[0][0]["properties"][0]['property']['origin']
assert isinstance(copy_origin, str)
# Create a MaterialRun, and make sure an inappropriate value for sample_type throws ValueError
with pytest.raises(ValueError):
mat = MaterialRun(spec=mat_spec, sample_type="imaginary")
mat = MaterialRun(spec=mat_spec, sample_type="virtual")
# ensure that serialization does not change the MaterialRun
copy = loads(dumps(mat))
assert dumps(copy) == dumps(mat), \
"Material run is modified by serialization or deserialization"
def test_build():
"""Test that build recreates the material."""
spec = MaterialSpec(
"A spec",
properties=PropertyAndConditions(
property=Property("a property", value=NominalReal(3, ''))),
tags=["a tag"])
mat = MaterialRun(name="a material", spec=spec)
mat_dict = mat.as_dict()
mat_dict['spec'] = mat.spec.as_dict()
assert MaterialRun.build(mat_dict) == mat
def test_equality():
"""Test that equality check works as expected."""
spec = MaterialSpec(
"A spec",
properties=PropertyAndConditions(
property=Property("a property", value=NominalReal(3, ''))),
tags=["a tag"])
mat1 = MaterialRun("A material", spec=spec)
mat2 = MaterialRun("A material", spec=spec, tags=["A tag"])
assert mat1 == deepcopy(mat1)
assert mat1 != mat2
assert mat1 != "A material"
def test_fields_from_property():
"""Test that several fields of the attribute are derived from the property."""
prop_template = PropertyTemplate(name="cookie eating template",
bounds=IntegerBounds(0, 1000))
cond_template = ConditionTemplate(name="Hunger template",
bounds=CategoricalBounds(
["hungry", "full", "peckish"]))
prop = Property(name="number of cookies eaten",
template=prop_template,
origin='measured',
value=NominalInteger(27))
cond = Condition(name="hunger level",
template=cond_template,
origin='specified',
value=NominalCategorical("hungry"))
prop_and_conds = PropertyAndConditions(property=prop, conditions=[cond])
assert prop_and_conds.name == prop.name
assert prop_and_conds.template == prop.template
assert prop_and_conds.origin == prop.origin
assert prop_and_conds.value == prop.value
def make_strehlow_objects(table=None):
"""Make a table with Strehlow & Cook data."""
tmpl = make_templates()
if table is None:
table = import_table()
# Specs
msr_spec = MeasurementSpec(name='Band gap',
template=tmpl["Band gap measurement"])
def real_mapper(prop):
"""Mapping methods for RealBounds."""
if 'uncertainty' in prop['scalars'][0]:
val = NormalReal(mean=float(prop['scalars'][0]['value']),
units=prop['units'],
std=float(prop['scalars'][0]['uncertainty']))
else:
val = NominalReal(nominal=float(prop['scalars'][0]['value']),
units=prop['units'])
return val
content_map = {
RealBounds:
real_mapper,
CategoricalBounds:
lambda prop: NominalCategorical(category=prop['scalars'][0]['value']),
type(None):
lambda bnd: 'Label'
}
datapoints = []
compounds = dict()
for row in table:
formula = formula_clean(row['chemicalFormula'])
spec = compounds.get(
formula,
MaterialSpec(name=formula_latex(formula),
template=tmpl["Chemical"],
process=ProcessSpec(
name="Sample preparation",
template=tmpl["Sample preparation"])))
run = make_instance(spec)
datapoints.append(run)
if not spec.properties:
spec.properties.append(
PropertyAndConditions(property=Property(
name=spec.template.properties[0][0].name,
value=EmpiricalFormula(formula=formula),
template=spec.template.properties[0][0])))
msr = make_instance(msr_spec)
msr.material = run
# 2 categories in the PIF need to be split to avoid repeat Attribute Templates in a Run
name_map = {'Phase': 'Crystal system', 'Transition': 'Bands'}
origin_map = {
'EXPERIMENTAL': Origin.MEASURED,
'COMPUTATIONAL': Origin.COMPUTED
}
seen = set(
) # Some conditions come in from multiple properties on the same object
for prop in row['properties']:
origin = origin_map.get(prop.get('dataType', None), Origin.UNKNOWN)
if 'method' in prop:
method = 'Method: ' + prop['method']['name']
else:
method = 'Method: unreported'
for attr in [prop] + prop.get('conditions', []):
if attr['name'] in seen:
# Early return if it's a repeat
continue
seen.add(attr['name'])
template = tmpl[attr['name']]
# Figure out if we need to split this column
if attr['name'] in name_map:
value = attr['scalars'][0]['value']
if value not in template.bounds.categories:
template = tmpl[name_map[attr['name']]]
# Move into GEMD structure
if type(template) == PropertyTemplate:
msr.properties.append(
Property(name=template.name,
template=template,
value=content_map[type(
template.bounds)](attr),
origin=origin,
notes=method))
elif type(template) == ConditionTemplate:
msr.conditions.append(
Condition(name=template.name,
template=template,
value=content_map[type(
template.bounds)](attr),
origin=origin,
notes=method))
return datapoints