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)
