def test_invalid_object_deserialize(): class Foo: pass obj = Object(Foo) with pytest.raises(AttributeError): obj.deserialize({'key': 'value'})
class SampleClass(Serializable): """A class to stress the deser scheme's ability to handle objects.""" prop_string = String('prop_string.string', default='default') prop_value = Object(BaseValue, 'prop_value') prop_object = Optional(Object(UnserializableClass), 'prop_object') def __init__(self, prop_string: str, prop_value: BaseValue, prop_object: Any = None): self.prop_string = prop_string self.prop_value = prop_value self.prop_object = prop_object
class Parameter(DataConcepts, Serializable['Parameter'], TaurusParameter): """ A parameter attribute. Parameters are the non-environmental variables (typically specified and controlled) that may affect a process or measurement: e.g. oven dial temperature for a kiln firing, magnification for a measurement taken with an electron microscope. Parameters ---------- name: str Required name of the parameter. Each parameter within an object must have a unique name. notes: str Optional free-form notes about the parameter. value: :py:class:`BaseValue <taurus.entity.value.base_value.BaseValue>` The value of the parameter. template: :class:`ParameterTemplate <citrine.resources.parameter_template.ParameterTemplate>` Parameter template that defines the allowed bounds of this parameter. If a template and value are both present then the value must be within the template bounds. origin: str The origin of the parameter. Must be one of "measured", "predicted", "summary", "specified", "computed", or "unknown." Default is "unknown." file_links: List[FileLink] Links to files associated with the parameter. """ _response_key = TaurusParameter.typ # 'parameter' name = String('name') notes = PropertyOptional(String(), 'notes') value = PropertyOptional(Object(BaseValue), 'value') template = PropertyOptional(LinkOrElse(), 'template') origin = PropertyOptional(String(), 'origin', default='unknown') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type', default=_response_key, deserializable=False) def __init__(self, name: str, notes: Optional[str] = None, value: Optional[BaseValue] = None, template: Optional[TaurusParameterTemplate] = None, origin: Optional[str] = "unknown", file_links: Optional[List[FileLink]] = None): TaurusParameter.__init__(self, name=name, notes=notes, value=value, template=template, origin=origin, file_links=file_links) def __str__(self): return '<Parameter {!r}>'.format(self.name)
class Property(DataConcepts, Serializable['Property'], TaurusProperty): """ A property attribute. Properties are characteristics of a material that could be measured, e.g. chemical composition, density, yield strength. Parameters ---------- name: str Required name of the property. Each property within an object must have a unique name. notes: str Optional free-form notes about the property. value: :py:class:`BaseValue <taurus.entity.value.base_value.BaseValue>` The value of the property. template: :class:`PropertyTemplate <citrine.resources.property_template.PropertyTemplate>` Property template that defines the allowed bounds of this property. If a template and value are both present then the value must be within the template bounds. origin: str The origin of the property. Must be one of "measured", "predicted", "summary", "specified", "computed", or "unknown." Default is "unknown." file_links: List[FileLink] Links to files associated with the property. """ _response_key = TaurusProperty.typ # 'property' name = String('name') notes = PropertyOptional(String(), 'notes') value = PropertyOptional(Object(BaseValue), 'value') template = PropertyOptional(LinkOrElse(), 'template') origin = PropertyOptional(String(), 'origin', default='unknown') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type', default=_response_key, deserializable=False) def __init__(self, name: str, notes: Optional[str] = None, value: Optional[BaseValue] = None, template: Optional[TaurusPropertyTemplate] = None, origin: Optional[str] = "unknown", file_links: Optional[List[FileLink]] = None): TaurusProperty.__init__(self, name=name, notes=notes, value=value, template=template, origin=origin, file_links=file_links) def __str__(self): return '<Property {!r}>'.format(self.name)
class CsvColumnInfo(Serializable): """The info for a CSV Column, contains the name, recommended and exact bounds.""" name = String('name') """:str: name of the column""" bounds = Object(BaseBounds, 'bounds') """:BaseBounds: recommended bounds of the column (might include some padding)""" exact_range_bounds = Object(BaseBounds, 'exact_range_bounds') """:BaseBounds: exact bounds of the column""" def __init__(self, name: String, bounds: BaseBounds, exact_range_bounds: BaseBounds): # pragma: no cover self.name = name self.bounds = bounds self.exact_range_bounds = exact_range_bounds
class JobStatusResponse(Resource['JobStatusResponse']): """[ALPHA] a response to a job status check. The JobStatusResponse summarizes the status for the entire job. Parameters ---------- job_type: str the type of job for this status report status: str the actual status of the job. One of "Running", "Success", or "Failure". tasks: List[TaskNode] all of the constituent task required to complete this job output: Optional[Map[String,String]] job output properties and results """ job_type = properties.String("job_type") status = properties.String("status") tasks = properties.List(Object(TaskNode), "tasks") output = properties.Optional(properties.Mapping(String, String), 'output') def __init__( self, job_type: str, status: str, tasks: List[TaskNode], output: Optional[Dict[str, str]] ): self.job_type = job_type self.status = status self.tasks = tasks self.output = output
class ConditionTemplate(AttributeTemplate, Resource['ConditionTemplate'], GEMDConditionTemplate): """ A condition template. Parameters ---------- name: str The name of the condition template. bounds: :py:class:`BaseBounds <gemd.entity.bounds.base_bounds.BaseBounds>` Bounds circumscribe the values that are valid according to this condition template. description: str, optional A long-form description of the condition template. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. """ _response_key = GEMDConditionTemplate.typ # 'condition_template' name = String('name') description = PropertyOptional(String(), 'description') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') bounds = Object(BaseBounds, 'bounds') typ = String('type') def __init__(self, name: str, *, bounds: BaseBounds, uids: Optional[Dict[str, str]] = None, description: Optional[str] = None, tags: Optional[List[str]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDConditionTemplate.typ) GEMDConditionTemplate.__init__(self, name=name, bounds=bounds, tags=tags, uids=uids, description=description) def __str__(self): return '<Condition template {!r}>'.format(self.name)
class PropertyAndConditions(DataConcepts, Serializable['PropertyAndConditions'], TaurusPropertyAndConditions): """ A compound attribute with one property and a list of relevant conditions. In the MaterialSpec object, one may need to specify a property along with the conditions under which the property occurs. For example: * Vapor pressure of 5.6 kPa at a temperature of 35 deg C * Gas phase at a pressure of 1 kPa and a temperature of 300 K Parameters ---------- property: :class:`Property <citrine.attributes.property.Property>` A property attribute conditions: List[:class:`Condition <citrine.attributes.condition.Condition>`] An optional list of conditions associated with this property """ _response_key = TaurusPropertyAndConditions.typ # 'property_and_conditions' property = Object(Property, 'property') conditions = PropertyOptional(PropertyList(Object(Condition)), 'conditions') typ = String('type', default=_response_key, deserializable=False) def __init__(self, property: Property, conditions: Optional[List[Condition]] = []): TaurusPropertyAndConditions.__init__(self, property=property, conditions=conditions) def __str__(self): return '<Property And Conditions ' \ '{!r} and {!r}>'.format(self.property.name, [cond.name for cond in self.conditions])
class CsvValidationData(FileProcessingData, Serializable): """The resulting data from the processed CSV file.""" columns = PropertyOptional(PropertyList(Object(CsvColumnInfo)), 'columns', override=True) """:Optional[List[CsvColumnInfo]]: all of the columns in the CSV""" record_count = Integer('record_count') """:int: the number of rows in the CSV""" def __init__(self, columns: List[CsvColumnInfo], record_count: int): # pragma: no cover self.columns = columns self.record_count = record_count
def test_set_serialize_unsortable(): """ Serializing a set of predictor evaluation metrics results in a list of dictionaries, which cannot be sorted. Attempting to serialize the data should work, but the order cannot be guaranteed, hence why we assert each metric is in the serialized value individually. """ data = {RMSE(), CoverageProbability()} serialized = Set(Object(PredictorEvaluationMetric)).serialize(data) for metric in data: assert metric.dump() in serialized
def test_union_runtime_errors(): """ De/serialization of Union ignores value errors. They indicate that a specific property is not the one that should be used for de/ser. If a different type of value error occurs then it can result in a difficult-to-diagnose error state and a runtime error is thrown. This test illustrates how that can happen for both serialization and deserialization. """ # The underlying type is correct (BaseEnumeration) but FOO is not part of that enumeration with pytest.raises(RuntimeError): Union([Enumeration(BaseEnumeration)]).serialize(EnumerationExample.FOO) # The serialized type is correct (dict) but it is missing fields incomplete_dataset_dict = {'name': 'name'} with pytest.raises(RuntimeError): Union([Object(Dataset)]).deserialize(incomplete_dataset_dict)
class ParameterTemplate(DataConcepts, Resource['ParameterTemplate'], TaurusParameterTemplate): """ A parameter template. Parameters ---------- name: str The name of the parameter template. bounds: :py:class:`BaseBounds <taurus.entity.bounds.base_bounds.BaseBounds>` Bounds circumscribe the values that are valid according to this parameter template. description: str, optional A long-form description of the parameter template. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. """ _response_key = TaurusParameterTemplate.typ # 'parameter_template' name = String('name') description = PropertyOptional(String(), 'description') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') bounds = Object(BaseBounds, 'bounds') typ = String('type') 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, TaurusParameterTemplate.typ) TaurusParameterTemplate.__init__(self, name=name, bounds=bounds, tags=tags, uids=set_default_uid(uids), description=description) def __str__(self): return '<Parameter template {!r}>'.format(self.name)
class ProcessRun(ObjectRun, Resource['ProcessRun'], GEMDProcessRun): """ A process run. Processes transform zero or more input materials into exactly one output material. Parameters ---------- name: str Name of the process run. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the process run. conditions: List[Condition], optional Conditions under which this process run occurs. parameters: List[Parameter], optional Parameters of this process run. spec: ProcessSpec Spec for this process run. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. source: PerformedSource, optional Information about the person who performed the run and when. Attributes ---------- output_material: MaterialRun The material run that this process run produces. The link is established by creating the material run and settings its `process` field to this process run. ingredients: List[IngredientRun] Ingredient runs that act as inputs to this process run. The link is established by creating each ingredient run and setting its `process` field to this process run. """ _response_key = GEMDProcessRun.typ # 'process_run' name = String('name', override=True) uids = Mapping(String('scope'), String('id'), 'uids', override=True) tags = PropertyOptional(PropertyList(String()), 'tags', override=True) notes = PropertyOptional(String(), 'notes', override=True) conditions = PropertyOptional(PropertyList(Object(Condition)), 'conditions', override=True) parameters = PropertyOptional(PropertyList(Object(Parameter)), 'parameters', override=True) spec = PropertyOptional(LinkOrElse(), 'spec', override=True) file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links', override=True) source = PropertyOptional(Object(PerformedSource), "source", override=True) typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, conditions: Optional[List[Condition]] = None, parameters: Optional[List[Parameter]] = None, spec: Optional[GEMDProcessSpec] = None, file_links: Optional[List[FileLink]] = None, source: Optional[PerformedSource] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDProcessRun.typ) GEMDProcessRun.__init__(self, name=name, uids=uids, tags=tags, conditions=conditions, parameters=parameters, spec=spec, file_links=file_links, notes=notes, source=source) def __str__(self): return '<Process run {!r}>'.format(self.name)
def test_object_str_representation(): assert "<Object[NominalReal] 'foo'>" == str(Object(NominalReal, 'foo'))
class MeasurementTemplate(ObjectTemplate, Resource['MeasurementTemplate'], GEMDMeasurementTemplate): """ A measurement template. Measurement templates are collections of condition, parameter and property templates that constrain the values of a measurement's condition, parameter and property attributes, and provide a common structure for describing similar measurements. Parameters ---------- name: str The name of the measurement template. description: str, optional Long-form description of the measurement template. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. conditions: List[ConditionTemplate] or List[ConditionTemplate, \ :py:class:`BaseBounds <gemd.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated conditions. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this condition. parameters: List[ParameterTemplate] or List[ParameterTemplate, \ :py:class:`BaseBounds <gemd.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated parameters. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this parameter. properties: List[PropertyTemplate] or List[PropertyTemplate, \ :py:class:`BaseBounds <gemd.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated properties. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this property. """ _response_key = GEMDMeasurementTemplate.typ # 'measurement_template' name = String('name') description = PropertyOptional(String(), 'description') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') properties = PropertyOptional( PropertyList( SpecifiedMixedList( [LinkOrElse, PropertyOptional(Object(BaseBounds))])), 'properties') conditions = PropertyOptional( PropertyList( SpecifiedMixedList( [LinkOrElse, PropertyOptional(Object(BaseBounds))])), 'conditions') parameters = PropertyOptional( PropertyList( SpecifiedMixedList( [LinkOrElse, PropertyOptional(Object(BaseBounds))])), 'parameters') typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, properties: Optional[Sequence[ Union[PropertyTemplate, LinkByUID, Sequence[Union[PropertyTemplate, LinkByUID, Optional[BaseBounds]]]]]] = None, conditions: Optional[Sequence[ Union[ConditionTemplate, LinkByUID, Sequence[Union[ConditionTemplate, LinkByUID, Optional[BaseBounds]]]]]] = None, parameters: Optional[Sequence[ Union[ParameterTemplate, LinkByUID, Sequence[Union[ParameterTemplate, LinkByUID, Optional[BaseBounds]]]]]] = None, description: Optional[str] = None, tags: Optional[List[str]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDMeasurementTemplate.typ) GEMDMeasurementTemplate.__init__(self, name=name, properties=properties, conditions=conditions, parameters=parameters, tags=tags, uids=uids, description=description) def __str__(self): return '<Measurement template {!r}>'.format(self.name)
class MaterialTemplate(DataConcepts, Resource['MaterialTemplate'], TaurusMaterialTemplate): """ A material template. Material templates are collections of property templates that constrain the values of a material's property attributes, and provide a common structure for describing similar materials. Parameters ---------- name: str The name of the material template. description: str, optional Long-form description of the material template. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. properties: List[PropertyTemplate] or List[PropertyTemplate, \ :py:class:`BaseBounds <taurus.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated properties. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this property. """ _response_key = TaurusMaterialTemplate.typ # 'material_template' name = String('name') description = PropertyOptional(String(), 'description') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') properties = PropertyOptional( PropertyList(MixedList([LinkOrElse, Object(BaseBounds)])), 'properties') typ = String('type') def __init__(self, name: str, uids: Optional[Dict[str, str]] = None, properties: Optional[Sequence[ Union[PropertyTemplate, LinkByUID, Sequence[Union[PropertyTemplate, LinkByUID, BaseBounds]]]]] = None, description: Optional[str] = None, tags: Optional[List[str]] = None): # properties is a list, each element of which is a PropertyTemplate OR is a list with # 2 entries: [PropertyTemplate, BaseBounds]. Python typing is not expressive enough, so # the typing above is more general. DataConcepts.__init__(self, TaurusMaterialTemplate.typ) TaurusMaterialTemplate.__init__(self, name=name, properties=properties, uids=set_default_uid(uids), tags=tags, description=description) @classmethod def _build_child_objects(cls, data: dict, session: Session = None): """ Build the property templates and bounds. Parameters ---------- data: dict A serialized material template. session: Session, optional Citrine session used to connect to the database. Returns ------- None The serialized material template is modified so that its properties are [PropertyTemplate, Bounds]. """ if 'properties' in data and len(data['properties']) != 0: # Each entry in the list data['properties'] has a property template as the 1st entry # and a base bounds as the 2nd entry. They are built in different ways. data['properties'] = [[ PropertyTemplate.build(prop[0].as_dict()), loads(dumps(prop[1])) ] for prop in data['properties']] def __str__(self): return '<Material template {!r}>'.format(self.name)
class ProcessRun(DataConcepts, Resource['ProcessRun'], TaurusProcessRun): """ A process run. Processes transform zero or more input materials into exactly one output material. Parameters ---------- name: str Name of the process run. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the process run. conditions: List[Condition], optional Conditions under which this process run occurs. parameters: List[Parameter], optional Parameters of this process run. spec: ProcessSpec Spec for this process run. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. source: PerformedSource, optional Information about the person who performed the run and when. Attributes ---------- output_material: MaterialRun The material run that this process run produces. The link is established by creating the material run and settings its `process` field to this process run. ingredients: List[IngredientRun] Ingredient runs that act as inputs to this process run. The link is established by creating each ingredient run and setting its `process` field to this process run. """ _response_key = TaurusProcessRun.typ # 'process_run' name = String('name') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') conditions = PropertyOptional(PropertyList(Object(Condition)), 'conditions') parameters = PropertyOptional(PropertyList(Object(Parameter)), 'parameters') spec = PropertyOptional(LinkOrElse(), 'spec') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') source = PropertyOptional(Object(PerformedSource), "source") typ = String('type') def __init__(self, name: str, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, conditions: Optional[List[Condition]] = None, parameters: Optional[List[Parameter]] = None, spec: Optional[TaurusProcessSpec] = None, file_links: Optional[List[FileLink]] = None, source: Optional[PerformedSource] = None): DataConcepts.__init__(self, TaurusProcessRun.typ) TaurusProcessRun.__init__(self, name=name, uids=set_default_uid(uids), tags=tags, conditions=conditions, parameters=parameters, spec=spec, file_links=file_links, notes=notes, source=source) def __str__(self): return '<Process run {!r}>'.format(self.name) @classmethod def _build_discarded_objects(cls, obj, obj_with_soft_links, session: Session = None): """ Build the IngredientRun objects that this ProcessRun has soft links to. The ingredient runs are found in `obj_with_soft_link` This method modifies the object in place. Parameters ---------- obj: ProcessRun A ProcessRun object that might be missing some links to IngredientRun objects. obj_with_soft_links: dict or \ :py:class:`DictSerializable <taurus.entity.dict_serializable.DictSerializable>` A representation of the ProcessRun in which the IngredientRuns are encoded. We consider both the possibility that this is a dictionary with an 'ingredients' key and that it is a :py:class:`DictSerializable <taurus.entity.dict_serializable.DictSerializable>` (presumably a :py:class:`TaurusProcessRun <taurus.entity.process_run.ProcessRun>`) with a .ingredients field. session: Session, optional Citrine session used to connect to the database. Returns ------- None The ProcessRun object is modified so that it has links to its IngredientRuns. """ from citrine.resources.ingredient_run import IngredientRun DataConcepts._build_list_of_soft_links(obj, obj_with_soft_links, field='ingredients', reverse_field='process', linked_type=IngredientRun, session=session)
class MaterialTemplate(ObjectTemplate, Resource['MaterialTemplate'], GEMDMaterialTemplate): """ A material template. Material templates are collections of property templates that constrain the values of a material's property attributes, and provide a common structure for describing similar materials. Parameters ---------- name: str The name of the material template. description: str, optional Long-form description of the material template. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. properties: List[PropertyTemplate] or List[PropertyTemplate, \ :py:class:`BaseBounds <gemd.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated properties. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this property. """ _response_key = GEMDMaterialTemplate.typ # 'material_template' name = String('name', override=True) description = PropertyOptional(String(), 'description', override=True) uids = Mapping(String('scope'), String('id'), 'uids', override=True) tags = PropertyOptional(PropertyList(String()), 'tags', override=True) properties = PropertyOptional(PropertyList(PropertyUnion([LinkOrElse, SpecifiedMixedList( [LinkOrElse, PropertyOptional(Object(BaseBounds))])])), 'properties', override=True) typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, properties: Optional[Sequence[Union[PropertyTemplate, LinkByUID, Sequence[Union[PropertyTemplate, LinkByUID, Optional[BaseBounds]]] ]]] = None, description: Optional[str] = None, tags: Optional[List[str]] = None): # properties is a list, each element of which is a PropertyTemplate OR is a list with # 2 entries: [PropertyTemplate, BaseBounds]. Python typing is not expressive enough, so # the typing above is more general. if uids is None: uids = dict() DataConcepts.__init__(self, GEMDMaterialTemplate.typ) GEMDMaterialTemplate.__init__(self, name=name, properties=properties, uids=uids, tags=tags, description=description) def __str__(self): return '<Material template {!r}>'.format(self.name)
class IngredientRun(DataConcepts, Resource['IngredientRun'], TaurusIngredientRun): """ An ingredient run. Ingredients annotate a material with information about its usage in a process. Parameters ---------- uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the ingredient run. material: MaterialRun Material that this ingredient is. process: ProcessRun Process that this ingredient is used in. mass_fraction: :py:class:`ContinuousValue \ <taurus.entity.value.continuous_value.ContinuousValue>`, optional The mass fraction of the ingredient in the process. volume_fraction: :py:class:`ContinuousValue \ <taurus.entity.value.continuous_value.ContinuousValue>`, optional The volume fraction of the ingredient in the process. number_fraction: :py:class:`ContinuousValue \ <taurus.entity.value.continuous_value.ContinuousValue>`, optional The number fraction of the ingredient in the process. absolute_quantity: :py:class:`ContinuousValue \ <taurus.entity.value.continuous_value.ContinuousValue>`, optional The absolute quantity of the ingredient in the process. name: str Label on the ingredient that is unique within the process that contains it. labels: List[str], optional Additional labels on the ingredient that must be unique. spec: IngredientSpec The specification of which this ingredient is a realization. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. """ _response_key = TaurusIngredientRun.typ # 'ingredient_run' uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') material = PropertyOptional(LinkOrElse(), 'material') process = PropertyOptional(LinkOrElse(), 'process') mass_fraction = PropertyOptional(Object(ContinuousValue), 'mass_fraction') volume_fraction = PropertyOptional(Object(ContinuousValue), 'volume_fraction') number_fraction = PropertyOptional(Object(ContinuousValue), 'number_fraction') absolute_quantity = PropertyOptional(Object(ContinuousValue), 'absolute_quantity') name = String('name') labels = PropertyOptional(PropertyList(String()), 'labels') spec = PropertyOptional(LinkOrElse(), 'spec') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type') def __init__(self, name: str, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, material: Optional[TaurusMaterialRun] = None, process: Optional[TaurusProcessRun] = None, mass_fraction: Optional[ContinuousValue] = None, volume_fraction: Optional[ContinuousValue] = None, number_fraction: Optional[ContinuousValue] = None, absolute_quantity: Optional[ContinuousValue] = None, labels: Optional[List[str]] = None, spec: Optional[TaurusIngredientSpec] = None, file_links: Optional[List[FileLink]] = None): DataConcepts.__init__(self, TaurusIngredientRun.typ) TaurusIngredientRun.__init__(self, uids=set_default_uid(uids), tags=tags, notes=notes, material=material, process=process, mass_fraction=mass_fraction, volume_fraction=volume_fraction, number_fraction=number_fraction, absolute_quantity=absolute_quantity, labels=labels, name=name, spec=spec, file_links=file_links) def __str__(self): return '<Ingredient run {!r}>'.format(self.name)
class IngredientSpec(ObjectSpec, Resource['IngredientSpec'], GEMDIngredientSpec): """ An ingredient specification. Ingredients annotate a material with information about its usage in a process. Parameters ---------- uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the ingredient spec. material: MaterialSpec Material that this ingredient is. process: ProcessSpec Process that this ingredient is used in. mass_fraction: :py:class:`ContinuousValue \ <gemd.entity.value.continuous_value.ContinuousValue>`, optional The mass fraction of the ingredient in the process. volume_fraction: :py:class:`ContinuousValue \ <gemd.entity.value.continuous_value.ContinuousValue>`, optional The volume fraction of the ingredient in the process. number_fraction: :py:class:`ContinuousValue \ <gemd.entity.value.continuous_value.ContinuousValue>`, optional The number fraction of the ingredient in the process. absolute_quantity: :py:class:`ContinuousValue \ <gemd.entity.value.continuous_value.ContinuousValue>`, optional The absolute quantity of the ingredient in the process. name: str Label on the ingredient that is unique within the process that contains it. labels: List[str], optional Additional labels on the ingredient. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. """ _response_key = GEMDIngredientSpec.typ # 'ingredient_spec' uids = Mapping(String('scope'), String('id'), 'uids', override=True) tags = PropertyOptional(PropertyList(String()), 'tags', override=True) notes = PropertyOptional(String(), 'notes', override=True) material = PropertyOptional(LinkOrElse(), 'material', override=True) process = PropertyOptional(LinkOrElse(), 'process', override=True) mass_fraction = PropertyOptional(Object(ContinuousValue), 'mass_fraction', override=True) volume_fraction = PropertyOptional(Object(ContinuousValue), 'volume_fraction', override=True) number_fraction = PropertyOptional(Object(ContinuousValue), 'number_fraction', override=True) absolute_quantity = PropertyOptional( Object(ContinuousValue), 'absolute_quantity', override=True) name = String('name', override=True) labels = PropertyOptional(PropertyList(String()), 'labels', override=True) file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links', override=True) typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, material: Optional[GEMDMaterialSpec] = None, process: Optional[GEMDProcessSpec] = None, mass_fraction: Optional[ContinuousValue] = None, volume_fraction: Optional[ContinuousValue] = None, number_fraction: Optional[ContinuousValue] = None, absolute_quantity: Optional[ContinuousValue] = None, labels: Optional[List[str]] = None, file_links: Optional[List[FileLink]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDIngredientSpec.typ) GEMDIngredientSpec.__init__(self, uids=uids, tags=tags, notes=notes, material=material, process=process, mass_fraction=mass_fraction, volume_fraction=volume_fraction, number_fraction=number_fraction, absolute_quantity=absolute_quantity, labels=labels, name=name, file_links=file_links) def __str__(self): return '<Ingredient spec {!r}>'.format(self.name)
class MaterialRun(DataConcepts, Resource['MaterialRun'], TaurusMaterialRun): """ A material run. Parameters ---------- name: str Name of the material run. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the material run. process: ProcessRun Process that produces this material. sample_type: str, optional The form of this sample. Optionals are "experimental", "virtual", "production", or "unknown." Default is "unknown." spec: MaterialSpec The material specification of which this is an instance. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. Attributes ---------- measurements: List[MeasurementRun], optional Measurements performed on this material. The link is established by creating the measurement run and settings its `material` field to this material run. """ _response_key = TaurusMaterialRun.typ # 'material_run' name = String('name') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') process = PropertyOptional(LinkOrElse(), 'process') sample_type = String('sample_type') spec = PropertyOptional(LinkOrElse(), 'spec') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type') def __init__(self, name: str, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, process: Optional[TaurusProcessRun] = None, sample_type: Optional[str] = "unknown", spec: Optional[TaurusMaterialSpec] = None, file_links: Optional[List[FileLink]] = None): DataConcepts.__init__(self, TaurusMaterialRun.typ) TaurusMaterialRun.__init__(self, name=name, uids=set_default_uid(uids), tags=tags, process=process, sample_type=sample_type, spec=spec, file_links=file_links, notes=notes) def __str__(self): return '<Material run {!r}>'.format(self.name) @classmethod def _build_discarded_objects(cls, obj, obj_with_soft_links, session: Session = None): """ Build the MeasurementRun objects that this MaterialRun has soft links to. The measurement runs are found in `obj_with_soft_link` This method modifies the object in place. Parameters ---------- obj: MaterialRun A MaterialRun object that might be missing some links to MeasurementRun objects. obj_with_soft_links: dict or \ :py:class:`DictSerializable <taurus.entity.dict_serializable.DictSerializable>` A representation of the MaterialRun in which the MeasurementRuns are encoded. We consider both the possibility that this is a dictionary with a 'measurements' key and that it is a :py:class:`DictSerializable <taurus.entity.dict_serializable.DictSerializable>` (presumably a :py:class:`TaurusMeasurementRun <taurus.entity.measurement_run.MeasurementRun>`) with a .measurements field. session: Session, optional Citrine session used to connect to the database. Returns ------- None The MaterialRun object is modified so that it has links to its MeasurementRuns. """ from citrine.resources.measurement_run import MeasurementRun DataConcepts._build_list_of_soft_links(obj, obj_with_soft_links, field='measurements', reverse_field='material', linked_type=MeasurementRun, session=session)
class MeasurementRun(DataConcepts, Resource['MeasurementRun'], TaurusMeasurementRun): """ A measurement run. Parameters ---------- name: str Name of the measurement run. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the measurement run. conditions: List[Condition], optional Conditions under which this measurement run occurs. parameters: List[Parameter], optional Parameters of this measurement run. properties: List[Property], optional Properties that are measured during this measurement run. spec: MeasurementSpec The measurement specification of which this is an instance. material: MaterialRun The material run being measured. spec: MaterialSpec The material specification of which this is an instance. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. source: PerformedSource, optional Information about the person who performed the run and when. """ _response_key = TaurusMeasurementRun.typ # 'measurement_run' name = String('name') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') conditions = PropertyOptional(PropertyList(Object(Condition)), 'conditions') parameters = PropertyOptional(PropertyList(Object(Parameter)), 'parameters') properties = PropertyOptional(PropertyList(Object(Property)), 'properties') spec = PropertyOptional(LinkOrElse(), 'spec') material = PropertyOptional(LinkOrElse(), "material") file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') source = PropertyOptional(Object(PerformedSource), "source") typ = String('type') def __init__(self, name: str, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, conditions: Optional[List[Condition]] = None, properties: Optional[List[Property]] = None, parameters: Optional[List[Parameter]] = None, spec: Optional[TaurusMeasurementSpec] = None, material: Optional[TaurusMaterialRun] = None, file_links: Optional[List[FileLink]] = None, source: Optional[PerformedSource] = None): DataConcepts.__init__(self, TaurusMeasurementRun.typ) TaurusMeasurementRun.__init__(self, name=name, uids=set_default_uid(uids), material=material, tags=tags, conditions=conditions, properties=properties, parameters=parameters, spec=spec, file_links=file_links, notes=notes, source=source) def __str__(self): return '<Measurement run {!r}>'.format(self.name)
class ProcessTemplate(DataConcepts, Resource['ProcessTemplate'], TaurusProcessTemplate): """ A process template. Process templates are collections of condition and parameter templates that constrain the values of a measurement's condition and parameter attributes, and provide a common structure for describing similar measurements. Parameters ---------- name: str The name of the process template. description: str, optional Long-form description of the process template. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/taurus-documentation/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/taurus-documentation/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. conditions: List[ConditionTemplate] or List[ConditionTemplate, \ :py:class:`BaseBounds <taurus.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated conditions. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this condition. parameters: List[ParameterTemplate] or List[ParameterTemplate, \ :py:class:`BaseBounds <taurus.entity.bounds.base_bounds.BaseBounds>`], optional Templates for associated parameters. Each template can be provided by itself, or as a list with the second entry being a separate, *more restrictive* Bounds object that defines the limits of the value for this parameter. """ _response_key = TaurusProcessTemplate.typ # 'process_template' name = String('name') description = PropertyOptional(String(), 'description') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') conditions = PropertyOptional( PropertyList(MixedList([LinkOrElse, Object(BaseBounds)])), 'conditions') parameters = PropertyOptional( PropertyList(MixedList([LinkOrElse, Object(BaseBounds)])), 'parameters') allowed_labels = PropertyOptional(PropertyList(String()), 'allowed_labels') allowed_names = PropertyOptional(PropertyList(String()), 'allowed_names') typ = String('type') def __init__(self, name: str, uids: Optional[Dict[str, str]] = None, conditions: Optional[Sequence[ Union[ConditionTemplate, LinkByUID, Sequence[Union[ConditionTemplate, LinkByUID, BaseBounds]]]]] = None, parameters: Optional[Sequence[ Union[ParameterTemplate, LinkByUID, Sequence[Union[ParameterTemplate, LinkByUID, BaseBounds]]]]] = None, allowed_labels: Optional[List[str]] = None, allowed_names: Optional[List[str]] = None, description: Optional[str] = None, tags: Optional[List[str]] = None): DataConcepts.__init__(self, TaurusProcessTemplate.typ) TaurusProcessTemplate.__init__(self, name=name, uids=set_default_uid(uids), conditions=conditions, parameters=parameters, tags=tags, description=description, allowed_labels=allowed_labels, allowed_names=allowed_names) @classmethod def _build_child_objects(cls, data: dict, session: Session = None): """ Build the condition and parameter templates and bounds. Parameters ---------- data: dict A serialized material template. session: Session, optional Citrine session used to connect to the database. Returns ------- None The serialized process template is modified so that its conditions are now a list of object pairs of the form [ConditionTemplate, :py:class:`BaseBounds <taurus.entity.bounds.base_bounds.BaseBounds>`], and the parameters are [ParameterTemplate, :py:class:`BaseBounds <taurus.entity.bounds.base_bounds.BaseBounds>`]. """ if 'conditions' in data and len(data['conditions']) != 0: data['conditions'] = [[ ConditionTemplate.build(cond[0].as_dict()), loads(dumps(cond[1])) ] for cond in data['conditions']] if 'parameters' in data and len(data['parameters']) != 0: data['parameters'] = [[ ParameterTemplate.build(param[0].as_dict()), loads(dumps(param[1])) ] for param in data['parameters']] def __str__(self): return '<Process template {!r}>'.format(self.name)
class MeasurementSpec(ObjectSpec, Resource['MeasurementSpec'], GEMDMeasurementSpec): """ A measurement specification. Parameters ---------- name: str Name of the measurement spec. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the measurement spec. conditions: List[Condition], optional Conditions under which this measurement spec occurs. parameters: List[Parameter], optional Parameters of this measurement spec. template: MeasurementTemplate A template bounding the valid values for the measurement's properties, parameters, and conditions. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. """ _response_key = GEMDMeasurementSpec.typ # 'measurement_spec' name = String('name') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') conditions = PropertyOptional(PropertyList(Object(Condition)), 'conditions') parameters = PropertyOptional(PropertyList(Object(Parameter)), 'parameters') template = PropertyOptional(LinkOrElse(), 'template') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, conditions: Optional[List[Condition]] = None, parameters: Optional[List[Parameter]] = None, template: Optional[GEMDMeasurementTemplate] = None, file_links: Optional[List[FileLink]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDMeasurementSpec.typ) GEMDMeasurementSpec.__init__(self, name=name, uids=uids, tags=tags, conditions=conditions, parameters=parameters, template=template, file_links=file_links, notes=notes) def __str__(self): return '<Measurement spec {!r}>'.format(self.name)
class MaterialRun(ObjectRun, Resource['MaterialRun'], GEMDMaterialRun): """ A material run. Parameters ---------- name: str Name of the material run. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the material run. process: ProcessRun Process that produces this material. sample_type: str, optional The form of this sample. Optionals are "experimental", "virtual", "production", or "unknown." Default is "unknown." spec: MaterialSpec The material specification of which this is an instance. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. Attributes ---------- measurements: List[MeasurementRun], optional Measurements performed on this material. The link is established by creating the measurement run and settings its `material` field to this material run. """ _response_key = GEMDMaterialRun.typ # 'material_run' name = String('name') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') process = PropertyOptional(LinkOrElse(), 'process') sample_type = String('sample_type') spec = PropertyOptional(LinkOrElse(), 'spec') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, process: Optional[GEMDProcessRun] = None, sample_type: Optional[str] = "unknown", spec: Optional[GEMDMaterialSpec] = None, file_links: Optional[List[FileLink]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDMaterialRun.typ) GEMDMaterialRun.__init__(self, name=name, uids=uids, tags=tags, process=process, sample_type=sample_type, spec=spec, file_links=file_links, notes=notes) def __str__(self): return '<Material run {!r}>'.format(self.name)
class MaterialSpec(ObjectSpec, Resource['MaterialSpec'], GEMDMaterialSpec): """ A material specification. Parameters ---------- name: str Name of the material spec. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the material spec. process: ProcessSpec Process that produces this material. properties: List[PropertyAndConditions], optional Properties of the material, along with an optional list of conditions under which those properties are measured. template: MaterialTemplate, optional A template bounding the valid values for this material's properties. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. """ _response_key = GEMDMaterialSpec.typ # 'material_spec' name = String('name', override=True) uids = Mapping(String('scope'), String('id'), 'uids', override=True) tags = PropertyOptional(PropertyList(String()), 'tags', override=True) notes = PropertyOptional(String(), 'notes', override=True) process = PropertyOptional(LinkOrElse(), 'process', override=True) properties = PropertyOptional(PropertyList(Object(PropertyAndConditions)), 'properties', override=True) template = PropertyOptional(LinkOrElse(), 'template', override=True) file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links', override=True) typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, process: Optional[GEMDProcessSpec] = None, properties: Optional[List[PropertyAndConditions]] = None, template: Optional[GEMDMaterialTemplate] = None, file_links: Optional[List[FileLink]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDMaterialSpec.typ) GEMDMaterialSpec.__init__(self, name=name, uids=uids, tags=tags, process=process, properties=properties, template=template, file_links=file_links, notes=notes) def __str__(self): return '<Material spec {!r}>'.format(self.name)
class ProcessSpec(ObjectSpec, Resource['ProcessSpec'], GEMDProcessSpec): """ A process specification. Processes transform zero or more input materials into exactly one output material. Parameters ---------- name: str Name of the process spec. uids: Map[str, str], optional A collection of `unique IDs <https://citrineinformatics.github.io/gemd-docs/ specification/unique-identifiers/>`_. tags: List[str], optional `Tags <https://citrineinformatics.github.io/gemd-docs/specification/tags/>`_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. notes: str, optional Long-form notes about the process spec. conditions: List[Condition], optional Conditions under which this process spec occurs. parameters: List[Parameter], optional Parameters of this process spec. template: ProcessTemplate, optional A template bounding the valid values for this process's parameters and conditions. file_links: List[FileLink], optional Links to associated files, with resource paths into the files API. Attributes ---------- output_material: MaterialSpec The material spec that this process spec produces. The link is established by creating the material spec and settings its `process` field to this process spec. ingredients: List[IngredientSpec], optional Ingredient specs that act as inputs to this process spec. The link is established by creating each ingredient spec and setting its `process` field to this process spec. """ _response_key = GEMDProcessSpec.typ # 'process_spec' name = String('name') uids = Mapping(String('scope'), String('id'), 'uids') tags = PropertyOptional(PropertyList(String()), 'tags') notes = PropertyOptional(String(), 'notes') conditions = PropertyOptional(PropertyList(Object(Condition)), 'conditions') parameters = PropertyOptional(PropertyList(Object(Parameter)), 'parameters') template = PropertyOptional(LinkOrElse(), 'template') file_links = PropertyOptional(PropertyList(Object(FileLink)), 'file_links') typ = String('type') def __init__(self, name: str, *, uids: Optional[Dict[str, str]] = None, tags: Optional[List[str]] = None, notes: Optional[str] = None, conditions: Optional[List[Condition]] = None, parameters: Optional[List[Parameter]] = None, template: Optional[GEMDProcessTemplate] = None, file_links: Optional[List[FileLink]] = None): if uids is None: uids = dict() DataConcepts.__init__(self, GEMDProcessSpec.typ) GEMDProcessSpec.__init__(self, name=name, uids=uids, tags=tags, conditions=conditions, parameters=parameters, template=template, file_links=file_links, notes=notes) def __str__(self): return '<Process spec {!r}>'.format(self.name)