class BiosampleProcessing(NamedThing): """ A process that takes one or more biosamples as inputs and generates one or as outputs. Examples of outputs include samples cultivated from another sample or data objects created by instruments runs. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.BiosampleProcessing class_class_curie: ClassVar[str] = "nmdc:BiosampleProcessing" class_name: ClassVar[str] = "biosample processing" class_model_uri: ClassVar[URIRef] = NMDC.BiosampleProcessing has_input: List[Union[dict, Biosample]] = empty_list() annotations: List[Union[dict, "Annotation"]] = empty_list() def __post_init__(self): self.has_input = [ v if isinstance(v, Biosample) else Biosample(**v) for v in self.has_input ] self.annotations = [ v if isinstance(v, Annotation) else Annotation(**v) for v in self.annotations ] super().__post_init__()
class OmicsProcessing(BiosampleProcessing): """ The methods and processes used to generate omics data from a biosample or organism. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.OmicsProcessing class_class_curie: ClassVar[str] = "nmdc:OmicsProcessing" class_name: ClassVar[str] = "omics processing" class_model_uri: ClassVar[URIRef] = NMDC.OmicsProcessing id: Optional[str] = None name: Optional[str] = None alternate_identifiers: List[str] = empty_list() part_of: List[Union[dict, Study]] = empty_list() has_output: List[Union[dict, DataObject]] = empty_list() def __post_init__(self): self.part_of = [ v if isinstance(v, Study) else Study(**v) for v in self.part_of ] self.has_output = [ v if isinstance(v, DataObject) else DataObject(**v) for v in self.has_output ] super().__post_init__()
class Definition(Element): """ base class for definitions """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = META.Definition class_class_curie: ClassVar[str] = "meta:Definition" class_name: ClassVar[str] = "definition" class_model_uri: ClassVar[URIRef] = META.Definition name: Union[str, DefinitionName] = None is_a: Optional[Union[str, DefinitionName]] = None abstract: Optional[Bool] = None mixin: Optional[Bool] = None mixins: List[Union[str, DefinitionName]] = empty_list() apply_to: List[Union[str, DefinitionName]] = empty_list() values_from: List[Union[str, URIorCURIE]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.is_a is not None and not isinstance(self.is_a, DefinitionName): self.is_a = DefinitionName(self.is_a) self.mixins = [ v if isinstance(v, DefinitionName) else DefinitionName(v) for v in self.mixins ] self.apply_to = [ v if isinstance(v, DefinitionName) else DefinitionName(v) for v in self.apply_to ] self.values_from = [ v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.values_from ] super().__post_init__(**kwargs)
class ValueSetDefinitionEntry(YAMLRoot): """ An element of a value set definition that, when resolved yields a set of entity references that are to be included in, excluded from or intersected with the set of elements that represent the full resolution of the definition. Note that only ACTIVE entity references are included. INACTIVE entity references may never be considered for inclusion or exclusion in the resolution of a value set definition. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.ValueSetDefinitionEntry class_class_curie: ClassVar[str] = "tccm:ValueSetDefinitionEntry" class_name: ClassVar[str] = "ValueSetDefinitionEntry" class_model_uri: ClassVar[URIRef] = TCCM.ValueSetDefinitionEntry include: List[Union[dict, "FormalDefinition"]] = empty_list() exclude: List[Union[dict, "FormalDefinition"]] = empty_list() intersect: List[Union[dict, "FormalDefinition"]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): self.include = [FormalDefinition(*e) for e in self.include.items()] if isinstance(self.include, dict) \ else [v if isinstance(v, FormalDefinition) else FormalDefinition(**v) for v in ([self.include] if isinstance(self.include, str) else self.include)] self.exclude = [FormalDefinition(*e) for e in self.exclude.items()] if isinstance(self.exclude, dict) \ else [v if isinstance(v, FormalDefinition) else FormalDefinition(**v) for v in ([self.exclude] if isinstance(self.exclude, str) else self.exclude)] self.intersect = [FormalDefinition(*e) for e in self.intersect.items()] if isinstance(self.intersect, dict) \ else [v if isinstance(v, FormalDefinition) else FormalDefinition(**v) for v in ([self.intersect] if isinstance(self.intersect, str) else self.intersect)] super().__post_init__(**kwargs)
class Biosample(YAMLRoot): """ A material sample. May be environmental (encompassing many organisms) or isolate or tissue """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.Biosample class_class_curie: ClassVar[str] = "nmdc:Biosample" class_name: ClassVar[str] = "biosample" class_model_uri: ClassVar[URIRef] = NMDC.Biosample id: Union[ElementIdentifier, BiosampleId] name: Optional[str] = None annotations: List[Union[dict, "Annotation"]] = empty_list() alternate_identifiers: List[ElementIdentifier] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, BiosampleId): self.id = BiosampleId(self.id) self.annotations = [Annotation(*e) for e in self.annotations.items()] if isinstance(self.annotations, dict) \ else [v if isinstance(v, Annotation) else Annotation(**v) for v in ([self.annotations] if isinstance(self.annotations, str) else self.annotations)] super().__post_init__(**kwargs)
class MapEntry(YAMLRoot): """ A "complex map" that defines an ordered set of rules for mapping from "`mapFrom`" to one or more targets """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.MapEntry class_class_curie: ClassVar[str] = "tccm:MapEntry" class_name: ClassVar[str] = "MapEntry" class_model_uri: ClassVar[URIRef] = TCCM.MapEntry mapFrom: Union[dict, EntityReference] allMatchesFrom: List[Union[dict, "MapSet"]] = empty_list() firstMatchFrom: List[Union[dict, "MapSet"]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.mapFrom is None: raise ValueError(f"mapFrom must be supplied") if not isinstance(self.mapFrom, EntityReference): self.mapFrom = EntityReference(self.mapFrom) self.allMatchesFrom = [MapSet(*e) for e in self.allMatchesFrom.items()] if isinstance(self.allMatchesFrom, dict) \ else [v if isinstance(v, MapSet) else MapSet(**v) for v in ([self.allMatchesFrom] if isinstance(self.allMatchesFrom, str) else self.allMatchesFrom)] self.firstMatchFrom = [MapSet(*e) for e in self.firstMatchFrom.items()] if isinstance(self.firstMatchFrom, dict) \ else [v if isinstance(v, MapSet) else MapSet(**v) for v in ([self.firstMatchFrom] if isinstance(self.firstMatchFrom, str) else self.firstMatchFrom)] super().__post_init__(**kwargs)
class Annotation(YAMLRoot): """ An annotation on a named thing. This is essentially a key value pair """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.Annotation class_class_curie: ClassVar[str] = "nmdc:Annotation" class_name: ClassVar[str] = "annotation" class_model_uri: ClassVar[URIRef] = NMDC.Annotation has_characteristic: List[Union[dict, Characteristic]] = empty_list() has_raw_value: Optional[str] = None has_normalized_value: List[Union[dict, NormalizedValue]] = empty_list() def __post_init__(self): self.has_characteristic = [ v if isinstance(v, Characteristic) else Characteristic(**v) for v in self.has_characteristic ] self.has_normalized_value = [ v if isinstance(v, NormalizedValue) else NormalizedValue(**v) for v in self.has_normalized_value ] super().__post_init__()
class SubsetDefinition(Element): """ the name and description of a subset """ _inherited_slots: ClassVar[List[str]] = [] # === element === name: Union[str, SubsetDefinitionName] = None id_prefixes: List[Union[str, NCName]] = empty_list() aliases: List[str] = empty_list() local_names: Union[dict, "LocalName"] = empty_dict() mappings: List[Union[str, URIorCURIE]] = empty_list() description: Optional[str] = None alt_descriptions: Union[dict, "AltDescription"] = empty_dict() deprecated: Optional[str] = None todos: List[str] = empty_list() notes: List[str] = empty_list() comments: List[str] = empty_list() examples: List[Union[dict, "Example"]] = empty_list() in_subset: List[Union[str, SubsetDefinitionName]] = empty_list() from_schema: Optional[Union[str, URI]] = None imported_from: Optional[str] = None see_also: List[Union[str, URIorCURIE]] = empty_list() # === subset_definition === def _fix_elements(self): super()._fix_elements() if self.name is not None and not isinstance(self.name, SubsetDefinitionName): self.name = SubsetDefinitionName(self.name)
class Medicine(ChemicalSubstance): """ Description of the contents of a medication """ _inherited_slots: ClassVar[List[str]] = [ "correlation", "related_to", "interacts_with", "has_phenotype", "molecularly_interacts_with", "affects_abundance_of", "increases_abundance_of", "decreases_abundance_of", "affects_activity_of", "increases_activity_of", "decreases_activity_of", "affects_expression_of", "increases_expression_of", "decreases_expression_of", "affects_folding_of", "increases_folding_of", "decreases_folding_of", "affects_localization_of", "increases_localization_of", "decreases_localization_of", "affects_metabolic_processing_of", "increases_metabolic_processing_of", "decreases_metabolic_processing_of", "affects_molecular_modification_of", "increases_molecular_modification_of", "decreases_molecular_modification_of", "affects_synthesis_of", "increases_synthesis_of", "decreases_synthesis_of", "affects_degradation_of", "increases_degradation_of", "decreases_degradation_of", "affects_mutation_rate_of", "increases_mutation_rate_of", "decreases_mutation_rate_of", "affects_response_to", "increases_response_to", "decreases_response_to", "affects_splicing_of", "increases_splicing_of", "decreases_splicing_of", "affects_stability_of", "increases_stability_of", "decreases_stability_of", "affects_transport_of", "increases_transport_of", "decreases_transport_of", "affects_secretion_of", "increases_secretion_of", "decreases_secretion_of", "affects_uptake_of", "increases_uptake_of", "decreases_uptake_of", "regulates_entity_to_entity", "biomarker_for", "in_taxon" ] class_class_uri: ClassVar[URIRef] = BIOLINK.Medicine class_class_curie: ClassVar[str] = "biolink:Medicine" class_name: ClassVar[str] = "medicine" class_model_uri: ClassVar[URIRef] = BIOLINK.Medicine id: Union[ElementIdentifier, MedicineId] = None name: Union[str, LabelType] = None category: List[Union[str, IriType]] = empty_list() has_active_ingredient: List[Union[ElementIdentifier, DrugId]] = empty_list() def __post_init__(self): if self.id is not None and not isinstance(self.id, MedicineId): self.id = MedicineId(self.id) self.has_active_ingredient = [ v if isinstance(v, DrugId) else DrugId(v) for v in self.has_active_ingredient ] super().__post_init__()
class Element(YAMLRoot): """ a named element in the model """ _inherited_slots: ClassVar[List[str]] = [] # === element === name: Union[str, ElementName] id_prefixes: List[Union[str, NCName]] = empty_list() aliases: List[str] = empty_list() local_names: Union[dict, "LocalName"] = empty_dict() mappings: List[Union[str, URIorCURIE]] = empty_list() description: Optional[str] = None alt_descriptions: Union[dict, "AltDescription"] = empty_dict() deprecated: Optional[str] = None todos: List[str] = empty_list() notes: List[str] = empty_list() comments: List[str] = empty_list() examples: List[Union[dict, "Example"]] = empty_list() in_subset: List[Union[str, SubsetDefinitionName]] = empty_list() from_schema: Optional[Union[str, URI]] = None imported_from: Optional[str] = None see_also: List[Union[str, URIorCURIE]] = empty_list() def _fix_elements(self): super()._fix_elements() self.id_prefixes = [ v if isinstance(v, NCName) else NCName(v) for v in self.id_prefixes ] if not isinstance(self.name, ElementName): self.name = ElementName(self.name) for k, v in self.local_names.items(): if not isinstance(v, LocalName): self.local_names[k] = LocalName(k, v) self.mappings = [ v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings ] for k, v in self.alt_descriptions.items(): if not isinstance(v, AltDescription): self.alt_descriptions[k] = AltDescription(k, v) self.examples = [ v if isinstance(v, Example) else Example(**v) for v in self.examples ] self.in_subset = [ v if isinstance(v, SubsetDefinitionName) else SubsetDefinitionName(v) for v in self.in_subset ] if self.from_schema is not None and not isinstance( self.from_schema, URI): self.from_schema = URI(self.from_schema) self.see_also = [ v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also ]
class ClassDefinition(Definition): """ the definition of a class or interface """ _inherited_slots: ClassVar[List[str]] = ["defining_slots"] class_class_uri: ClassVar[URIRef] = META.ClassDefinition class_class_curie: ClassVar[str] = "meta:ClassDefinition" class_name: ClassVar[str] = "class_definition" class_model_uri: ClassVar[URIRef] = META.ClassDefinition name: Union[str, ClassDefinitionName] = None slots: List[Union[str, SlotDefinitionName]] = empty_list() slot_usage: Dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]] = empty_dict() attributes: Dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]] = empty_dict() class_uri: Optional[Union[str, URIorCURIE]] = None subclass_of: Optional[Union[str, URIorCURIE]] = None union_of: List[Union[str, ClassDefinitionName]] = empty_list() defining_slots: List[Union[str, SlotDefinitionName]] = empty_list() tree_root: Optional[Bool] = None is_a: Optional[Union[str, ClassDefinitionName]] = None mixins: List[Union[str, ClassDefinitionName]] = empty_list() apply_to: List[Union[str, ClassDefinitionName]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.name is None: raise ValueError(f"name must be supplied") if not isinstance(self.name, ClassDefinitionName): self.name = ClassDefinitionName(self.name) self.slots = [v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in ([self.slots] if isinstance(self.slots, str) else self.slots)] for k, v in self.slot_usage.items(): if not isinstance(v, SlotDefinition): self.slot_usage[k] = SlotDefinition(name=k, **({} if v is None else v)) for k, v in self.attributes.items(): if not isinstance(v, SlotDefinition): self.attributes[k] = SlotDefinition(name=k, **({} if v is None else v)) if self.class_uri is not None and not isinstance(self.class_uri, URIorCURIE): self.class_uri = URIorCURIE(self.class_uri) if self.subclass_of is not None and not isinstance(self.subclass_of, URIorCURIE): self.subclass_of = URIorCURIE(self.subclass_of) self.union_of = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in ([self.union_of] if isinstance(self.union_of, str) else self.union_of)] self.defining_slots = [v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in ([self.defining_slots] if isinstance(self.defining_slots, str) else self.defining_slots)] if self.is_a is not None and not isinstance(self.is_a, ClassDefinitionName): self.is_a = ClassDefinitionName(self.is_a) self.mixins = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in ([self.mixins] if isinstance(self.mixins, str) else self.mixins)] self.apply_to = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in ([self.apply_to] if isinstance(self.apply_to, str) else self.apply_to)] super().__post_init__(**kwargs)
class Biosample(YAMLRoot): """ A material sample. May be environmental (encompassing many organisms) or isolate or tissue """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.Biosample class_class_curie: ClassVar[str] = "nmdc:Biosample" class_name: ClassVar[str] = "biosample" class_model_uri: ClassVar[URIRef] = NMDC.Biosample id: Union[ElementIdentifier, BiosampleId] = None name: Optional[str] = None annotations: Optional[Union[Union[dict, "Annotation"], List[Union[dict, "Annotation"]]]] = empty_list() alternate_identifiers: Optional[Union[ ElementIdentifier, List[ElementIdentifier]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.id is None: raise ValueError("id must be supplied") if not isinstance(self.id, BiosampleId): self.id = BiosampleId(self.id) if self.name is not None and not isinstance(self.name, str): self.name = str(self.name) if self.annotations is None: self.annotations = [] if not isinstance(self.annotations, list): self.annotations = [self.annotations] self._normalize_inlined_slot(slot_name="annotations", slot_type=Annotation, key_name="has raw value", inlined_as_list=True, keyed=False) if self.alternate_identifiers is None: self.alternate_identifiers = [] if not isinstance(self.alternate_identifiers, list): self.alternate_identifiers = [self.alternate_identifiers] self.alternate_identifiers = [ v if isinstance(v, ElementIdentifier) else ElementIdentifier(v) for v in self.alternate_identifiers ] super().__post_init__(**kwargs)
class Annotation(Extension): """ a tag/value pair with the semantics of OWL Annotation """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = META.Annotation class_class_curie: ClassVar[str] = "meta:Annotation" class_name: ClassVar[str] = "annotation" class_model_uri: ClassVar[URIRef] = META.Annotation tag: Union[str, URIorCURIE] = None value: str = None annotations: Optional[Union[Union[dict, "Annotation"], List[Union[dict, "Annotation"]]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.annotations is None: self.annotations = [] if not isinstance(self.annotations, list): self.annotations = [self.annotations] self._normalize_inlined_slot(slot_name="annotations", slot_type=Annotation, key_name="tag", inlined_as_list=True, keyed=False) super().__post_init__(**kwargs)
class ResolvedValueSetHeader(YAMLRoot): """ The information required to completely resolve a value set definition. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.ResolvedValueSetHeader class_class_curie: ClassVar[str] = "tccm:ResolvedValueSetHeader" class_name: ClassVar[str] = "ResolvedValueSetHeader" class_model_uri: ClassVar[URIRef] = TCCM.ResolvedValueSetHeader resolutionOf: Union[dict, ValueSetDefinitionReference] resolvedUsingCodeSystem: Dict[ Union[str, CodeSystemVersionReferenceName], Union[dict, CodeSystemVersionReference]] = empty_dict() includesResolvedValueSet: List[Union[ dict, "ResolvedValueSetHeader"]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.resolutionOf is None: raise ValueError(f"resolutionOf must be supplied") if not isinstance(self.resolutionOf, ValueSetDefinitionReference): self.resolutionOf = ValueSetDefinitionReference(self.resolutionOf) for k, v in self.resolvedUsingCodeSystem.items(): if not isinstance(v, CodeSystemVersionReference): self.resolvedUsingCodeSystem[k] = CodeSystemVersionReference( name=k, **({} if v is None else v)) self.includesResolvedValueSet = [ResolvedValueSetHeader(*e) for e in self.includesResolvedValueSet.items()] if isinstance(self.includesResolvedValueSet, dict) \ else [v if isinstance(v, ResolvedValueSetHeader) else ResolvedValueSetHeader(**v) for v in ([self.includesResolvedValueSet] if isinstance(self.includesResolvedValueSet, str) else self.includesResolvedValueSet)] super().__post_init__(**kwargs)
class Annotatable(YAMLRoot): """ mixin for classes that support annotations """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = META.Annotatable class_class_curie: ClassVar[str] = "meta:Annotatable" class_name: ClassVar[str] = "annotatable" class_model_uri: ClassVar[URIRef] = META.Annotatable annotations: Optional[Union[Union[dict, "Annotation"], List[Union[dict, "Annotation"]]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.annotations is None: self.annotations = [] if not isinstance(self.annotations, list): self.annotations = [self.annotations] self._normalize_inlined_slot(slot_name="annotations", slot_type=Annotation, key_name="tag", inlined_as_list=True, keyed=False) super().__post_init__(**kwargs)
class EntityReference(YAMLRoot): """ The URI, namespace/name (if known) and a list of code systems that make assertions about the entity. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.EntityReference class_class_curie: ClassVar[str] = "tccm:EntityReference" class_name: ClassVar[str] = "EntityReference" class_model_uri: ClassVar[URIRef] = TCCM.EntityReference code: Union[str, EntityReferenceCode] about: Optional[URIorCURIE] = None designation: Optional[str] = None description: Optional[str] = None href: Optional[Union[URIorCURIE, RenderingURI]] = None see_also: List[Union[URIorCURIE, RenderingURI]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.code is None: raise ValueError(f"code must be supplied") if not isinstance(self.code, EntityReferenceCode): self.code = EntityReferenceCode(self.code) if self.href is not None and not isinstance(self.href, RenderingURI): self.href = RenderingURI(self.href) self.see_also = [v if isinstance(v, RenderingURI) else RenderingURI(v) for v in ([self.see_also] if isinstance(self.see_also, str) else self.see_also)] super().__post_init__(**kwargs)
class Employee(YAMLRoot): """ A person """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = URIRef( "http://example.org/sample/organization/Employee") class_class_curie: ClassVar[str] = None class_name: ClassVar[str] = "employee" class_model_uri: ClassVar[URIRef] = URIRef( "http://example.org/sample/organization/Employee") id: Union[str, EmployeeId] last_name: str first_name: Optional[str] = None aliases: List[str] = empty_list() age_in_years: Optional[int] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, EmployeeId): self.id = EmployeeId(self.id) if self.last_name is None: raise ValueError(f"last_name must be supplied") super().__post_init__(**kwargs)
class ResourceDescription(YAMLRoot): """ ResourceDescription represents the shared characteristics common to both abstract and resource version descriptions. ResourceDescription is an abstract type and, as such, cannot be directly created. Resource descriptions are Changeable, meaning that they have identity and can be created, updated, and deleted. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.ResourceDescription class_class_curie: ClassVar[str] = "tccm:ResourceDescription" class_name: ClassVar[str] = "ResourceDescription" class_model_uri: ClassVar[URIRef] = TCCM.ResourceDescription about: Union[str, ExternalURI] resourceID: Union[str, LocalIdentifier] formalName: Optional[str] = None keyword: List[str] = empty_list() resourceSynopsis: Optional[str] = None additionalDocumentation: List[Union[str, PersistentURI]] = empty_list() rights: Optional[str] = None alternateID: Optional[str] = None extensions: List[Union[dict, Extension]] = empty_list() annotations: List[Union[dict, Annotation]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.about is None: raise ValueError(f"about must be supplied") if not isinstance(self.about, ExternalURI): self.about = ExternalURI(self.about) if self.resourceID is None: raise ValueError(f"resourceID must be supplied") if not isinstance(self.resourceID, LocalIdentifier): self.resourceID = LocalIdentifier(self.resourceID) self.additionalDocumentation = [ v if isinstance(v, PersistentURI) else PersistentURI(v) for v in ([self.additionalDocumentation] if isinstance( self.additionalDocumentation, str) else self. additionalDocumentation) ] self.extensions = [Extension(*e) for e in self.extensions.items()] if isinstance(self.extensions, dict) \ else [v if isinstance(v, Extension) else Extension(**v) for v in ([self.extensions] if isinstance(self.extensions, str) else self.extensions)] self.annotations = [Annotation(*e) for e in self.annotations.items()] if isinstance(self.annotations, dict) \ else [v if isinstance(v, Annotation) else Annotation(**v) for v in ([self.annotations] if isinstance(self.annotations, str) else self.annotations)] super().__post_init__(**kwargs)
class GOLRClass(YAMLRoot): id: str schema_generating: bool description: str display_name: str document_category: str weight: int fields: List[GOLRField] = empty_list()
class Definition(Element): """ base class for definitions """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = META.Definition class_class_curie: ClassVar[str] = "meta:Definition" class_name: ClassVar[str] = "definition" class_model_uri: ClassVar[URIRef] = META.Definition name: Union[str, DefinitionName] = None is_a: Optional[Union[str, DefinitionName]] = None abstract: Optional[Bool] = None mixin: Optional[Bool] = None mixins: List[Union[str, DefinitionName]] = empty_list() apply_to: List[Union[str, DefinitionName]] = empty_list() values_from: List[Union[str, URIorCURIE]] = empty_list() created_by: Optional[Union[str, URIorCURIE]] = None created_on: Optional[Union[str, XSDDateTime]] = None last_updated_on: Optional[Union[str, XSDDateTime]] = None modified_by: Optional[Union[str, URIorCURIE]] = None status: Optional[Union[str, URIorCURIE]] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.is_a is not None and not isinstance(self.is_a, DefinitionName): self.is_a = DefinitionName(self.is_a) self.mixins = [v if isinstance(v, DefinitionName) else DefinitionName(v) for v in ([self.mixins] if isinstance(self.mixins, str) else self.mixins)] self.apply_to = [v if isinstance(v, DefinitionName) else DefinitionName(v) for v in ([self.apply_to] if isinstance(self.apply_to, str) else self.apply_to)] self.values_from = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in ([self.values_from] if isinstance(self.values_from, str) else self.values_from)] if self.created_by is not None and not isinstance(self.created_by, URIorCURIE): self.created_by = URIorCURIE(self.created_by) if self.created_on is not None and not isinstance(self.created_on, XSDDateTime): self.created_on = XSDDateTime(self.created_on) if self.last_updated_on is not None and not isinstance(self.last_updated_on, XSDDateTime): self.last_updated_on = XSDDateTime(self.last_updated_on) if self.modified_by is not None and not isinstance(self.modified_by, URIorCURIE): self.modified_by = URIorCURIE(self.modified_by) if self.status is not None and not isinstance(self.status, URIorCURIE): self.status = URIorCURIE(self.status) super().__post_init__(**kwargs)
class MapSet(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.MapSet class_class_curie: ClassVar[str] = "tccm:MapSet" class_name: ClassVar[str] = "MapSet" class_model_uri: ClassVar[URIRef] = TCCM.MapSet allMatchesFrom: List[Union[dict, "MapTarget"]] = empty_list() firstMatchFrom: List[Union[dict, "MapTarget"]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): self.allMatchesFrom = [MapTarget(*e) for e in self.allMatchesFrom.items()] if isinstance(self.allMatchesFrom, dict) \ else [v if isinstance(v, MapTarget) else MapTarget(**v) for v in ([self.allMatchesFrom] if isinstance(self.allMatchesFrom, str) else self.allMatchesFrom)] self.firstMatchFrom = [MapTarget(*e) for e in self.firstMatchFrom.items()] if isinstance(self.firstMatchFrom, dict) \ else [v if isinstance(v, MapTarget) else MapTarget(**v) for v in ([self.firstMatchFrom] if isinstance(self.firstMatchFrom, str) else self.firstMatchFrom)] super().__post_init__(**kwargs)
class BiosampleProcessing(YAMLRoot): """ A process that takes one or more biosamples as inputs and generates one or more as output """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.BiosampleProcessing class_class_curie: ClassVar[str] = "nmdc:BiosampleProcessing" class_name: ClassVar[str] = "biosample processing" class_model_uri: ClassVar[URIRef] = NMDC.BiosampleProcessing input: List[Union[ElementIdentifier, BiosampleId]] = empty_list() output: List[Union[ElementIdentifier, BiosampleId]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): self.input = [v if isinstance(v, BiosampleId) else BiosampleId(v) for v in ([self.input] if isinstance(self.input, str) else self.input)] self.output = [v if isinstance(v, BiosampleId) else BiosampleId(v) for v in ([self.output] if isinstance(self.output, str) else self.output)] super().__post_init__(**kwargs)
class BiosampleProcessing(YAMLRoot): """ A process that takes one or more biosamples as inputs and generates one or more as output """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.BiosampleProcessing class_class_curie: ClassVar[str] = "nmdc:BiosampleProcessing" class_name: ClassVar[str] = "biosample processing" class_model_uri: ClassVar[URIRef] = NMDC.BiosampleProcessing input: List[Union[dict, Biosample]] = empty_list() output: List[Union[dict, Biosample]] = empty_list() def __post_init__(self): self.input = [v if isinstance(v, Biosample) else Biosample(**v) for v in self.input] self.output = [v if isinstance(v, Biosample) else Biosample(**v) for v in self.output] super().__post_init__()
class Biosample(NamedThing): """ A material sample. May be environmental (encompassing many organisms) or isolate or tissue """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.Biosample class_class_curie: ClassVar[str] = "nmdc:Biosample" class_name: ClassVar[str] = "biosample" class_model_uri: ClassVar[URIRef] = NMDC.Biosample id: Optional[str] = None name: Optional[str] = None alternate_identifiers: List[str] = empty_list() annotations: List[Union[dict, "Annotation"]] = empty_list() def __post_init__(self): self.annotations = [v if isinstance(v, Annotation) else Annotation(**v) for v in self.annotations] super().__post_init__()
class ConceptReference(YAMLRoot): """ A minimal description of a class, individual, term or similar construct """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = SKOS.Concept class_class_curie: ClassVar[str] = "skos:Concept" class_name: ClassVar[str] = "ConceptReference" class_model_uri: ClassVar[URIRef] = TERMCI.ConceptReference uri: Union[str, ConceptReferenceUri] = None code: str = None defined_in: Union[str, ConceptSystemNamespace] = None designation: Optional[str] = None definition: Optional[str] = None reference: Optional[Union[Union[str, URI], List[Union[str, URI]]]] = empty_list() narrower_than: Optional[Union[Union[str, ConceptReferenceUri], List[Union[str, ConceptReferenceUri]]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.uri is None: raise ValueError("uri must be supplied") if not isinstance(self.uri, ConceptReferenceUri): self.uri = ConceptReferenceUri(self.uri) if self.code is None: raise ValueError("code must be supplied") if not isinstance(self.code, str): self.code = str(self.code) if self.defined_in is None: raise ValueError("defined_in must be supplied") if not isinstance(self.defined_in, ConceptSystemNamespace): self.defined_in = ConceptSystemNamespace(self.defined_in) if self.designation is not None and not isinstance(self.designation, str): self.designation = str(self.designation) if self.definition is not None and not isinstance(self.definition, str): self.definition = str(self.definition) if self.reference is None: self.reference = [] if not isinstance(self.reference, list): self.reference = [self.reference] self.reference = [v if isinstance(v, URI) else URI(v) for v in self.reference] if self.narrower_than is None: self.narrower_than = [] if not isinstance(self.narrower_than, list): self.narrower_than = [self.narrower_than] self.narrower_than = [v if isinstance(v, ConceptReferenceUri) else ConceptReferenceUri(v) for v in self.narrower_than] super().__post_init__(**kwargs)
class ConceptSystem(YAMLRoot): """ A terminological resource (ontology, classification scheme, concept system, etc.) """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = SKOS.ConceptScheme class_class_curie: ClassVar[str] = "skos:ConceptScheme" class_name: ClassVar[str] = "ConceptSystem" class_model_uri: ClassVar[URIRef] = TERMCI.ConceptSystem namespace: Union[str, ConceptSystemNamespace] = None prefix: str = None description: Optional[str] = None reference: Optional[Union[Union[str, URI], List[Union[str, URI]]]] = empty_list() root_concept: Optional[Union[Union[str, ConceptReferenceUri], List[Union[str, ConceptReferenceUri]]]] = empty_list() contents: Optional[Union[Dict[Union[str, ConceptReferenceUri], Union[dict, ConceptReference]], List[Union[dict, ConceptReference]]]] = empty_dict() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.namespace is None: raise ValueError("namespace must be supplied") if not isinstance(self.namespace, ConceptSystemNamespace): self.namespace = ConceptSystemNamespace(self.namespace) if self.prefix is None: raise ValueError("prefix must be supplied") if not isinstance(self.prefix, str): self.prefix = str(self.prefix) if self.description is not None and not isinstance(self.description, str): self.description = str(self.description) if self.reference is None: self.reference = [] if not isinstance(self.reference, list): self.reference = [self.reference] self.reference = [v if isinstance(v, URI) else URI(v) for v in self.reference] if self.root_concept is None: self.root_concept = [] if not isinstance(self.root_concept, list): self.root_concept = [self.root_concept] self.root_concept = [v if isinstance(v, ConceptReferenceUri) else ConceptReferenceUri(v) for v in self.root_concept] if self.contents is None: self.contents = [] if not isinstance(self.contents, (list)): self.contents = [self.contents] self._normalize_inlined_slot(slot_name="contents", slot_type=ConceptReference, key_name="uri", inlined_as_list=True, keyed=True) super().__post_init__(**kwargs)
class Study(NamedThing): """ A study summarizes the overall goal of a research initiative and outlines the key objective of its underlying projects. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.Study class_class_curie: ClassVar[str] = "nmdc:Study" class_name: ClassVar[str] = "study" class_model_uri: ClassVar[URIRef] = NMDC.Study id: Optional[str] = None name: Optional[str] = None alternate_identifiers: List[str] = empty_list() annotations: List[Union[dict, "Annotation"]] = empty_list() def __post_init__(self): self.annotations = [ v if isinstance(v, Annotation) else Annotation(**v) for v in self.annotations ] super().__post_init__()
class NamedThing(YAMLRoot): """ a databased entity or concept/class """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.NamedThing class_class_curie: ClassVar[str] = "nmdc:NamedThing" class_name: ClassVar[str] = "named thing" class_model_uri: ClassVar[URIRef] = NMDC.NamedThing id: Optional[str] = None name: Optional[str] = None description: Optional[str] = None alternate_identifiers: List[str] = empty_list()
class ValueSetCatalogEntry(ValueSetCatalogEntryOrReference): """ A ValueSetCatalogEntry carries information about the creators, distributors, purpose, use, etc. about a value set. The catalog does not carry the actual definition of a value set as (a) this may vary over time and (b) it is possible for more than one definition to be in use at any given point in time. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TCCM.ValueSetCatalogEntry class_class_curie: ClassVar[str] = "tccm:ValueSetCatalogEntry" class_name: ClassVar[str] = "ValueSetCatalogEntry" class_model_uri: ClassVar[URIRef] = TCCM.ValueSetCatalogEntry id: Union[str, ValueSetCatalogEntryId] = None valueSetName: Union[str, ValueSetName] = None about: Union[URIorCURIE, ExternalURI] = None definitions: Dict[Union[str, ValueSetDefinitionReferenceName], Union[dict, ValueSetDefinitionReference]] = empty_dict() currentDefinition: Optional[Union[dict, ValueSetDefinitionReference]] = None currentResolution: Optional[Union[URIorCURIE, RenderingURI]] = None releaseDocumentation: Optional[str] = None releaseFormat: List[Union[dict, SourceAndNotation]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, ValueSetCatalogEntryId): self.id = ValueSetCatalogEntryId(self.id) if self.valueSetName is None: raise ValueError(f"valueSetName must be supplied") if not isinstance(self.valueSetName, ValueSetName): self.valueSetName = ValueSetName(self.valueSetName) for k, v in self.definitions.items(): if not isinstance(v, ValueSetDefinitionReference): self.definitions[k] = ValueSetDefinitionReference( name=k, **({} if v is None else v)) if self.currentDefinition is not None and not isinstance( self.currentDefinition, ValueSetDefinitionReference): self.currentDefinition = ValueSetDefinitionReference( self.currentDefinition) if self.currentResolution is not None and not isinstance( self.currentResolution, RenderingURI): self.currentResolution = RenderingURI(self.currentResolution) self.releaseFormat = [SourceAndNotation(*e) for e in self.releaseFormat.items()] if isinstance(self.releaseFormat, dict) \ else [v if isinstance(v, SourceAndNotation) else SourceAndNotation(**v) for v in ([self.releaseFormat] if isinstance(self.releaseFormat, str) else self.releaseFormat)] super().__post_init__(**kwargs)
class TypeDefinition(Element): """ A data type definition. """ _inherited_slots: ClassVar[List[str]] = ["base", "uri", "repr"] # === element === name: Union[str, TypeDefinitionName] = None id_prefixes: List[Union[str, NCName]] = empty_list() aliases: List[str] = empty_list() local_names: Union[dict, "LocalName"] = empty_dict() mappings: List[Union[str, URIorCURIE]] = empty_list() description: Optional[str] = None alt_descriptions: Union[dict, "AltDescription"] = empty_dict() deprecated: Optional[str] = None todos: List[str] = empty_list() notes: List[str] = empty_list() comments: List[str] = empty_list() examples: List[Union[dict, "Example"]] = empty_list() in_subset: List[Union[str, SubsetDefinitionName]] = empty_list() from_schema: Optional[Union[str, URI]] = None imported_from: Optional[str] = None see_also: List[Union[str, URIorCURIE]] = empty_list() # === type_definition === typeof: Optional[Union[str, TypeDefinitionName]] = None base: Optional[str] = None uri: Optional[Union[str, URIorCURIE]] = None repr: Optional[str] = None def _fix_elements(self): super()._fix_elements() if self.name is not None and not isinstance(self.name, TypeDefinitionName): self.name = TypeDefinitionName(self.name) if self.typeof is not None and not isinstance(self.typeof, TypeDefinitionName): self.typeof = TypeDefinitionName(self.typeof) if self.uri is not None and not isinstance(self.uri, URIorCURIE): self.uri = URIorCURIE(self.uri)