def __init__(self,
name: str,
*,
spec: Union[MaterialSpec, LinkByUID] = None,
process: Union[ProcessRun, LinkByUID] = None,
sample_type: Union[SampleType, str] = "unknown",
uids: Mapping[str, str] = None,
tags: Iterable[str] = None,
notes: str = None,
file_links: Optional[Union[Iterable[FileLink],
FileLink]] = None):
from gemd.entity.object.measurement_run import MeasurementRun
BaseObject.__init__(self,
name=name,
uids=uids,
tags=tags,
notes=notes,
file_links=file_links)
HasSpec.__init__(self, spec=spec)
self._process = None
self._measurements = validate_list(None, [MeasurementRun, LinkByUID])
self._sample_type = None
self.process = process
self.sample_type = sample_type
def parameters(self, parameters):
lst = validate_list(parameters, (ParameterTemplate, LinkByUID, list, tuple))
# make sure attribute can be a Parameter
# TODO: list.map(_.validate_scope(AttributeType.PARAMETER)) all true
self._parameters = list(map(BaseTemplate._homogenize_ranges, lst))
def conditions(self,
conditions: Iterable[Union[Union[ConditionTemplate,
LinkByUID],
Tuple[Union[ConditionTemplate,
LinkByUID],
Optional[BaseBounds]]]]):
"""
Set the list of condition templates.
Parameters
----------
conditions: List[(ConditionTemplate, bounds)]
A list of tuples containing this entity's condition templates as well
as any restrictions on those templates' bounds.
Returns
-------
List[(ConditionTemplate, bounds)]
List of this entity's condition template/bounds pairs
"""
if isinstance(conditions, Iterable):
if any(isinstance(x, BaseBounds) for x in conditions):
conditions = [conditions
] # It's a template/bounds tuple (probably)
self._conditions = validate_list(
conditions, (ConditionTemplate, LinkByUID, list, tuple),
trigger=BaseTemplate._homogenize_ranges)
def parameters(self, parameters: Iterable[Parameter]):
"""Set the list of parameters."""
checker = self._generate_template_check(
HasParameterTemplates.validate_parameter)
self._parameters = validate_list(parameters,
Parameter,
trigger=checker)
def properties(self, properties: Iterable[PropertyAndConditions]):
"""Set the list of property-and-conditions."""
checker = self._generate_template_check(
HasPropertyTemplates.validate_property)
self._properties = validate_list(properties,
PropertyAndConditions,
trigger=checker)
def __init__(self,
name: str,
*,
template: Optional[Union[ProcessTemplate, LinkByUID]] = None,
conditions: Iterable[Condition] = None,
parameters: Iterable[Parameter] = None,
uids: Mapping[str, str] = None,
tags: Iterable[str] = None,
notes: str = None,
file_links: Optional[Union[Iterable[FileLink],
FileLink]] = None):
from gemd.entity.object.ingredient_spec import IngredientSpec
from gemd.entity.link_by_uid import LinkByUID
BaseObject.__init__(self,
name=name,
uids=uids,
tags=tags,
notes=notes,
file_links=file_links)
HasTemplate.__init__(self, template=template)
HasParameters.__init__(self, parameters=parameters)
HasConditions.__init__(self, conditions=conditions)
# By default, a ProcessSpec is not linked to any MaterialSpec.
# If a MaterialSpec is linked to this ProcessSpec,
# then the field self._output_material will be automatically populated
self._output_material = None
self._ingredients = validate_list(None, [IngredientSpec, LinkByUID])
def conditions(self, conditions):
lst = validate_list(conditions, (ConditionTemplate, list, tuple))
# make sure attribute can be a Condition
# TODO: list.map(_.validate_scope(AttributeType.CONDITION)) all true
self._conditions = list(map(BaseTemplate._homogenize_ranges, lst))
def spec(self, spec: Union[IngredientSpec, LinkByUID]):
"""Set the spec."""
if isinstance(self.spec,
IngredientSpec): # Store values if you had them
self._name = self.spec.name
self._labels = validate_list(self.spec.labels, str)
# Note that the super() mechanism does not work properly for overloaded setters
getattr(HasSpec, "spec").fset(self, spec)
def properties(self, properties):
# make sure the properties are a list
lst = validate_list(properties, (PropertyTemplate, list, tuple))
# make sure attribute can be a Property
# TODO: list.map(_.validate_scope(AttributeType.PROPERTY)) all true
# convert any templates into (template, bounds) pairs and
# validate that any (template, bounds) pairs are consistent
self._properties = list(map(BaseTemplate._homogenize_ranges, lst))
def process(self, process):
from gemd.entity.object import ProcessRun
from gemd.entity.link_by_uid import LinkByUID
if self._process is not None and isinstance(self._process, ProcessRun):
self._process._unset_ingredient(self)
if process is None:
self._process = None
elif isinstance(process, ProcessRun):
self._process = process
if not isinstance(process.ingredients, ValidList):
process._ingredients = validate_list(
self, [IngredientRun, LinkByUID])
else:
process._ingredients.append(self)
elif isinstance(process, LinkByUID):
self._process = process
else:
raise TypeError("IngredientRun.process must be a ProcessRun or "
"LinkByUID: {}".format(process))
def material(self, value):
from gemd.entity.object import MaterialRun
from gemd.entity.link_by_uid import LinkByUID
if self._material is not None and isinstance(self._material,
MaterialRun):
self._material._unset_measurement(self)
if value is None:
self._material = value
elif isinstance(value, MaterialRun):
self._material = value
if not isinstance(value.measurements, ValidList):
value._measurements = validate_list(
self, [MeasurementRun, LinkByUID])
else:
value._measurements.append(self)
elif isinstance(value, LinkByUID):
self._material = value
else:
raise TypeError(
"material must be a MaterialRun or LinkByUID: {}".format(
value))
def __init__(self,
name: str,
*,
spec: Union[ProcessSpec, LinkByUID] = None,
conditions: Iterable[Condition] = None,
parameters: Iterable[Parameter] = None,
uids: Mapping[str, str] = None,
tags: Iterable[str] = None,
notes: str = None,
file_links: Optional[Union[Iterable[FileLink], FileLink]] = None,
source: PerformedSource = None):
from gemd.entity.object.ingredient_run import IngredientRun
BaseObject.__init__(self, name=name, uids=uids, tags=tags, notes=notes,
file_links=file_links)
HasSpec.__init__(self, spec=spec)
HasConditions.__init__(self, conditions)
HasParameters.__init__(self, parameters)
HasSource.__init__(self, source)
self._ingredients = validate_list(None, [IngredientRun, LinkByUID])
self._output_material = None
def from_dict(cls, d: Mapping[str, Any]) -> DictSerializable:
"""
Overloaded method from DictSerializable to intercept `name` and `labels` fields.
Parameters
----------
d: dict
The object as a dictionary of key-value pairs that correspond to the object's fields.
Returns
-------
DictSerializable
The deserialized object.
"""
name = d.pop("name", None)
labels = d.pop("labels", None)
obj = super().from_dict(d)
if name is not None:
obj._name = name
if labels is not None:
obj._labels = validate_list(labels, str)
return obj
def properties(self,
properties: Iterable[Union[Union[PropertyTemplate,
LinkByUID],
Tuple[Union[PropertyTemplate,
LinkByUID],
Optional[BaseBounds]]]]):
"""
Set the list of parameter templates.
Parameters
----------
properties: List[(PropertyTemplate, bounds)]
A list of tuples containing this entity's property templates as well
as any restrictions on those templates' bounds.
"""
if isinstance(properties, Iterable):
if any(isinstance(x, BaseBounds) for x in properties):
properties = [properties
] # It's a template/bounds tuple (probably)
self._properties = validate_list(
properties, (PropertyTemplate, LinkByUID, list, tuple),
trigger=BaseTemplate._homogenize_ranges)
def tags(self, tags: Iterable[str]):
self._tags = validate_list(tags, str)
def properties(self, properties):
self._properties = validate_list(properties, PropertyAndConditions)
def file_links(self, file_links: Union[Iterable[FileLink], FileLink]):
self._file_links = validate_list(file_links, FileLink)
def file_links(self, file_links):
self._file_links = validate_list(file_links, FileLink)
def allowed_labels(self, allowed_labels):
# if none, leave as none; don't set to the empty set
if allowed_labels is None:
self._allowed_labels = allowed_labels
else:
self._allowed_labels = validate_list(allowed_labels, str)
def allowed_labels(self, allowed_labels):
if allowed_labels is None:
self._allowed_labels = validate_list([], str)
else:
self._allowed_labels = validate_list(allowed_labels, str)
def allowed_names(self, allowed_names):
if allowed_names is None:
self._allowed_names = validate_list([], str)
else:
self._allowed_names = validate_list(allowed_names, str)
def labels(self, labels: Iterable[str]):
self._labels = validate_list(labels, str)
def properties(self, properties):
self._properties = validate_list(properties, Property)
def labels(self, labels):
self._labels = validate_list(labels, str)
def conditions(self, conditions: Iterable[Condition]):
self._conditions = validate_list(conditions, Condition)
def conditions(self, conditions):
self._conditions = validate_list(conditions, Condition)
def conditions(self, conditions: Iterable[Condition]):
"""Set the list of conditions."""
checker = self._generate_template_check(HasConditionTemplates.validate_condition)
self._conditions = validate_list(conditions, Condition, trigger=checker)
