def __init__(self,
name: str,
bounds: BaseBounds,
uids: Optional[Dict[str, str]] = None,
description: Optional[str] = None,
tags: Optional[List[str]] = None):
DataConcepts.__init__(self, TaurusPropertyTemplate.typ)
TaurusPropertyTemplate.__init__(self, name=name, bounds=bounds, tags=tags,
uids=set_default_uid(uids), description=description)
def make_cake_templates():
"""Define all templates independently, as in the wild this will be an independent operation."""
tmpl = dict()
# Attributes
tmpl['Cooking time'] = ConditionTemplate(
name="Cooking time",
description="The time elapsed during a cooking process",
bounds=RealBounds(0, 7 * 24.0, "hr")
)
tmpl["Oven temperature setting"] = ParameterTemplate(
name="Oven temperature setting",
description="Where the knob points",
bounds=RealBounds(0, 2000.0, "K")
)
tmpl["Oven temperature"] = ConditionTemplate(
name="Oven temperature",
description="Actual temperature measured by the thermocouple",
bounds=RealBounds(0, 2000.0, "K")
)
tmpl["Tastiness"] = PropertyTemplate(
name="Tastiness",
description="Yumminess on a fairly arbitrary scale",
bounds=IntegerBounds(lower_bound=1, upper_bound=10)
)
# Objects
tmpl["Baking in an oven"] = ProcessTemplate(
name="Baking in an oven",
description='Using heat to promote chemical reactions in a material',
allowed_labels=['precursor'],
conditions=[(tmpl["Oven temperature"], RealBounds(0, 700, "degF"))],
parameters=[(tmpl["Oven temperature setting"], RealBounds(100, 550, "degF"))]
)
tmpl["Taste test"] = MeasurementTemplate(
name="Taste test",
properties=[tmpl["Tastiness"]]
)
tmpl["Dessert"] = MaterialTemplate(
name="Dessert",
properties=[tmpl["Tastiness"]]
)
tmpl["Generic Material"] = MaterialTemplate(name="Generic")
tmpl["Icing"] = ProcessTemplate(name="Icing",
description='Applying a coating to a substrate',
allowed_labels=['coating', 'substrate'])
tmpl["Mixing"] = ProcessTemplate(name="Mixing",
description='Physically combining ingredients',
allowed_labels=['wet', 'dry', 'leavening', 'seasoning',
'sweetener', 'shortening', 'flavoring'])
tmpl["Procurement"] = ProcessTemplate(name="Procurement",
description="Buyin' stuff")
return tmpl
def test_attribute_serde():
"""An attribute with a link to an attribute template should be copy-able."""
prop_tmpl = PropertyTemplate(name='prop_tmpl',
bounds=RealBounds(0, 2, 'm')
)
prop = Property(name='prop',
template=prop_tmpl,
value=NominalReal(1, 'm')
)
meas_spec = MeasurementSpec("a spec")
meas = MeasurementRun("a measurement", spec=meas_spec, properties=[prop])
assert loads(dumps(prop)) == prop
assert loads(dumps(meas)) == meas
assert isinstance(prop.template, PropertyTemplate)
def test_recursive_foreach():
"""Test that recursive foreach will actually walk through a material history."""
mat_run = MaterialRun("foo")
process_run = ProcessRun("bar")
IngredientRun(process=process_run, material=mat_run)
output = MaterialRun(process=process_run)
# property templates are trickier than templates because they are referenced in attributes
template = PropertyTemplate("prop", bounds=RealBounds(0, 1, ""))
prop = Property("prop", value=NominalReal(1.0, ""), template=template)
MeasurementRun("check", material=output, properties=prop)
types = []
recursive_foreach(output, lambda x: types.append(x.typ))
expected = [
"ingredient_run", "material_run", "material_run", "process_run",
"measurement_run", "property_template"
]
assert sorted(types) == sorted(expected)
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 test_json():
"""Test that json serialization round robins to the identity."""
template = PropertyTemplate(name="foo", bounds=RealBounds(0, 1, ""))
copy = loads(dumps(template))
assert copy == template
from taurus.entity.bounds.real_bounds import RealBounds
from taurus.entity.object import MeasurementRun, MaterialRun, ProcessRun, ProcessSpec,\
MeasurementSpec, MaterialSpec
from taurus.entity.template.condition_template import ConditionTemplate
from taurus.entity.template.material_template import MaterialTemplate
from taurus.entity.template.measurement_template import MeasurementTemplate
from taurus.entity.template.process_template import ProcessTemplate
from taurus.entity.template.property_template import PropertyTemplate
from taurus.entity.value.discrete_categorical import DiscreteCategorical
from taurus.entity.value.nominal_composition import NominalComposition
from taurus.entity.value.nominal_real import NominalReal
from taurus.entity.value.normal_real import NormalReal
from taurus.entity.value.uniform_real import UniformReal
density_template = PropertyTemplate(
name="Density",
bounds=RealBounds(lower_bound=0, upper_bound=1.0e9, default_units='')
)
firing_temperature_template = ConditionTemplate(
name="Firing Temperature",
bounds=RealBounds(lower_bound=0, upper_bound=1.0e9, default_units='degC')
)
measurement_template = MeasurementTemplate(properties=density_template)
firing_template = ProcessTemplate(
name="Firing in a kiln",
conditions=(firing_temperature_template, RealBounds(lower_bound=500, upper_bound=1000,
default_units='degC'))
)
material_template = MaterialTemplate(
name="Some ceramic thing",
properties=density_template
from taurus.entity.attribute.condition import Condition
from taurus.entity.attribute.parameter import Parameter
from taurus.entity.attribute.property import Property
from taurus.entity.bounds.categorical_bounds import CategoricalBounds
from taurus.entity.bounds.real_bounds import RealBounds
from taurus.entity.object import MaterialRun, MeasurementRun
from taurus.entity.template.condition_template import ConditionTemplate
from taurus.entity.template.parameter_template import ParameterTemplate
from taurus.entity.template.property_template import PropertyTemplate
from taurus.entity.value.discrete_categorical import DiscreteCategorical
from taurus.entity.value.nominal_real import NominalReal
from taurus.entity.value.normal_real import NormalReal
known_properties = {
"density": PropertyTemplate(
name="density",
bounds=RealBounds(lower_bound=0.0, upper_bound=1000.0, default_units='g / cm^3')
),
"kinematic viscosity": PropertyTemplate(
name="kinematic viscosity",
bounds=RealBounds(lower_bound=0.0, upper_bound=10.0**40, default_units="m^2 / s")
)
}
known_conditions = {
"temperature": ConditionTemplate(
name="temperature",
bounds=RealBounds(lower_bound=0.0, upper_bound=1000.0, default_units='K')
)
}
known_parameters = {