class Person(YAMLRoot): """ A person, living or dead """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = FOAF.Person class_class_curie: ClassVar[str] = "foaf:Person" class_name: ClassVar[str] = "person" class_model_uri: ClassVar[URIRef] = PERS.Person id: Union[str, PersonId] = None last_name: str = None first_name: Optional[Union[str, List[str]]] = empty_list() living: Optional[Bool] = None age: Optional[int] = None knows: Optional[Union[Union[str, PersonId], List[Union[str, PersonId]]]] = 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, PersonId): self.id = PersonId(self.id) if self.last_name is None: raise ValueError("last_name must be supplied") if not isinstance(self.last_name, str): self.last_name = str(self.last_name) if self.first_name is None: self.first_name = [] if not isinstance(self.first_name, list): self.first_name = [self.first_name] self.first_name = [ v if isinstance(v, str) else str(v) for v in self.first_name ] if self.living is not None and not isinstance(self.living, Bool): self.living = Bool(self.living) if self.age is not None and not isinstance(self.age, int): self.age = int(self.age) if self.knows is None: self.knows = [] if not isinstance(self.knows, list): self.knows = [self.knows] self.knows = [ v if isinstance(v, PersonId) else PersonId(v) for v in self.knows ] super().__post_init__(**kwargs)
class Patient(Entity): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = CCDH.Patient class_class_curie: ClassVar[str] = "ccdh:Patient" class_name: ClassVar[str] = "Patient" class_model_uri: ClassVar[URIRef] = CCDH.Patient id: Union[str, PatientId] = None identifier: Optional[Union[Union[dict, "Identifier"], List[Union[dict, "Identifier"]]]] = empty_list() taxon: Optional[Union[dict, "CodeableConcept"]] = None 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, PatientId): self.id = PatientId(self.id) if self.identifier is None: self.identifier = [] if not isinstance(self.identifier, list): self.identifier = [self.identifier] self.identifier = [ v if isinstance(v, Identifier) else Identifier(**v) for v in self.identifier ] if self.taxon is not None and not isinstance(self.taxon, CodeableConcept): self.taxon = CodeableConcept(**self.taxon) 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] = LINKML.Annotation class_class_curie: ClassVar[str] = "linkml:Annotation" class_name: ClassVar[str] = "annotation" class_model_uri: ClassVar[URIRef] = LINKML.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 Extensible(YAMLRoot): """ mixin for classes that support extension """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = LINKML.Extensible class_class_curie: ClassVar[str] = "linkml:Extensible" class_name: ClassVar[str] = "extensible" class_model_uri: ClassVar[URIRef] = LINKML.Extensible extensions: Optional[Union[Union[dict, Extension], List[Union[dict, Extension]]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.extensions is None: self.extensions = [] if not isinstance(self.extensions, list): self.extensions = [self.extensions] self._normalize_inlined_slot(slot_name="extensions", slot_type=Extension, key_name="tag", inlined_as_list=True, keyed=False) 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 CodeableConcept(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = TYPES.CodeableConcept class_class_curie: ClassVar[str] = "types:CodeableConcept" class_name: ClassVar[str] = "CodeableConcept" class_model_uri: ClassVar[URIRef] = TYPES.CodeableConcept coding: Optional[Union[Union[dict, Coding], List[Union[dict, Coding]]]] = empty_list() text: Optional[str] = None def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.coding is None: self.coding = [] if not isinstance(self.coding, list): self.coding = [self.coding] self.coding = [ v if isinstance(v, Coding) else Coding(**v) for v in self.coding ] if self.text is not None and not isinstance(self.text, str): self.text = str(self.text) 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 Person(YAMLRoot): """ Minimal information about a person """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = SDO.Person class_class_curie: ClassVar[str] = "sdo:Person" class_name: ClassVar[str] = "Person" class_model_uri: ClassVar[URIRef] = EX.Person id: Union[str, PersonId] = None first_name: Union[str, List[str]] = None last_name: str = None knows: Optional[Union[Union[str, PersonId], List[Union[str, PersonId]]]] = 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, PersonId): self.id = PersonId(self.id) if self.first_name is None: raise ValueError("first_name must be supplied") elif not isinstance(self.first_name, list): self.first_name = [self.first_name] elif len(self.first_name) == 0: raise ValueError(f"first_name must be a non-empty list") self.first_name = [ v if isinstance(v, str) else str(v) for v in self.first_name ] if self.last_name is None: raise ValueError("last_name must be supplied") if not isinstance(self.last_name, str): self.last_name = str(self.last_name) if self.knows is None: self.knows = [] if not isinstance(self.knows, list): self.knows = [self.knows] self.knows = [ v if isinstance(v, PersonId) else PersonId(v) for v in self.knows ] 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()
class Extension(YAMLRoot): """ a tag/value pair used to add non-model information to an entry """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = LINKML.Extension class_class_curie: ClassVar[str] = "linkml:Extension" class_name: ClassVar[str] = "extension" class_model_uri: ClassVar[URIRef] = LINKML.Extension tag: Union[str, URIorCURIE] = None value: str = None extensions: Optional[Union[Union[dict, "Extension"], List[Union[dict, "Extension"]]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.tag is None: raise ValueError("tag must be supplied") if not isinstance(self.tag, URIorCURIE): self.tag = URIorCURIE(self.tag) if self.value is None: raise ValueError("value must be supplied") if not isinstance(self.value, str): self.value = str(self.value) if self.extensions is None: self.extensions = [] if not isinstance(self.extensions, list): self.extensions = [self.extensions] self._normalize_inlined_slot(slot_name="extensions", slot_type=Extension, key_name="tag", inlined_as_list=True, keyed=False) super().__post_init__(**kwargs)
class Specimen(Entity): """ Any material taken as a sample from a biological entity (living or dead), or from a physical object or the environment. Specimens are usually collected as an example of their kind, often for use in some investigation. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = CCDH.Specimen class_class_curie: ClassVar[str] = "ccdh:Specimen" class_name: ClassVar[str] = "Specimen" class_model_uri: ClassVar[URIRef] = CCDH.Specimen id: Union[str, SpecimenId] = None identifier: Optional[Union[Union[dict, "Identifier"], List[Union[dict, "Identifier"]]]] = empty_list() associated_project: Optional[Union[str, ProjectId]] = None specimen_type: Optional[Union[dict, "CodeableConcept"]] = None analyte_type: Optional[Union[dict, "CodeableConcept"]] = None derived_from_specimen: Optional[Union[Union[str, SpecimenId], List[Union[ str, SpecimenId]]]] = empty_list() derived_from_subject: Optional[Union[str, PatientId]] = None source_material_type: Optional[Union[dict, "CodeableConcept"]] = None cellular_composition: Optional[Union[dict, "CodeableConcept"]] = None general_tissue_morphology: Optional[Union[dict, "CodeableConcept"]] = None specific_tissue_morphology: Optional[Union[dict, "CodeableConcept"]] = None current_weight: Optional[Union[Union[dict, "Quantity"], List[Union[dict, "Quantity"]]]] = empty_list() current_volume: Optional[Union[Union[dict, "Quantity"], List[Union[dict, "Quantity"]]]] = empty_list() analyte_concentration: Optional[Union[dict, "Quantity"]] = None analyte_concentration_method: Optional[Union[dict, "CodeableConcept"]] = None matched_normal_flag: Optional[ Union[Union[dict, "CodeableConcept"], List[Union[dict, "CodeableConcept"]]]] = empty_list() qualification_status_flag: Optional[Union[dict, "CodeableConcept"]] = None 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, SpecimenId): self.id = SpecimenId(self.id) if self.identifier is None: self.identifier = [] if not isinstance(self.identifier, list): self.identifier = [self.identifier] self.identifier = [ v if isinstance(v, Identifier) else Identifier(**v) for v in self.identifier ] if self.associated_project is not None and not isinstance( self.associated_project, ProjectId): self.associated_project = ProjectId(self.associated_project) if self.specimen_type is not None and not isinstance( self.specimen_type, CodeableConcept): self.specimen_type = CodeableConcept(**self.specimen_type) if self.analyte_type is not None and not isinstance( self.analyte_type, CodeableConcept): self.analyte_type = CodeableConcept(**self.analyte_type) if self.derived_from_specimen is None: self.derived_from_specimen = [] if not isinstance(self.derived_from_specimen, list): self.derived_from_specimen = [self.derived_from_specimen] self.derived_from_specimen = [ v if isinstance(v, SpecimenId) else SpecimenId(v) for v in self.derived_from_specimen ] if self.derived_from_subject is not None and not isinstance( self.derived_from_subject, PatientId): self.derived_from_subject = PatientId(self.derived_from_subject) if self.source_material_type is not None and not isinstance( self.source_material_type, CodeableConcept): self.source_material_type = CodeableConcept( **self.source_material_type) if self.cellular_composition is not None and not isinstance( self.cellular_composition, CodeableConcept): self.cellular_composition = CodeableConcept( **self.cellular_composition) if self.general_tissue_morphology is not None and not isinstance( self.general_tissue_morphology, CodeableConcept): self.general_tissue_morphology = CodeableConcept( **self.general_tissue_morphology) if self.specific_tissue_morphology is not None and not isinstance( self.specific_tissue_morphology, CodeableConcept): self.specific_tissue_morphology = CodeableConcept( **self.specific_tissue_morphology) if self.current_weight is None: self.current_weight = [] if not isinstance(self.current_weight, list): self.current_weight = [self.current_weight] self.current_weight = [ v if isinstance(v, Quantity) else Quantity(**v) for v in self.current_weight ] if self.current_volume is None: self.current_volume = [] if not isinstance(self.current_volume, list): self.current_volume = [self.current_volume] self.current_volume = [ v if isinstance(v, Quantity) else Quantity(**v) for v in self.current_volume ] if self.analyte_concentration is not None and not isinstance( self.analyte_concentration, Quantity): self.analyte_concentration = Quantity(**self.analyte_concentration) if self.analyte_concentration_method is not None and not isinstance( self.analyte_concentration_method, CodeableConcept): self.analyte_concentration_method = CodeableConcept( **self.analyte_concentration_method) if self.matched_normal_flag is None: self.matched_normal_flag = [] if not isinstance(self.matched_normal_flag, list): self.matched_normal_flag = [self.matched_normal_flag] self.matched_normal_flag = [ v if isinstance(v, CodeableConcept) else CodeableConcept(**v) for v in self.matched_normal_flag ] if self.qualification_status_flag is not None and not isinstance( self.qualification_status_flag, CodeableConcept): self.qualification_status_flag = CodeableConcept( **self.qualification_status_flag) super().__post_init__(**kwargs)
class ResearchSubject(Entity): """ A research subject is the entity of interest in a research study, typically a human being or an animal, but can also be a device, group of humans or animals, or a tissue sample. Human research subjects are usually not traceable to a particular person to protect the subject’s privacy. """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = CCDH.ResearchSubject class_class_curie: ClassVar[str] = "ccdh:ResearchSubject" class_name: ClassVar[str] = "ResearchSubject" class_model_uri: ClassVar[URIRef] = CCDH.ResearchSubject id: Union[str, ResearchSubjectId] = None identifier: Optional[Union[Union[dict, "Identifier"], List[Union[dict, "Identifier"]]]] = empty_list() associated_project: Optional[Union[Union[str, ProjectId], List[Union[str, ProjectId]]]] = empty_list() primary_disease_type: Optional[Union[dict, "CodeableConcept"]] = None primary_disease_site: Optional[Union[dict, "CodeableConcept"]] = None associated_patient: Optional[Union[str, PatientId]] = None 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, ResearchSubjectId): self.id = ResearchSubjectId(self.id) if self.identifier is None: self.identifier = [] if not isinstance(self.identifier, list): self.identifier = [self.identifier] self.identifier = [ v if isinstance(v, Identifier) else Identifier(**v) for v in self.identifier ] if self.associated_project is None: self.associated_project = [] if not isinstance(self.associated_project, list): self.associated_project = [self.associated_project] self.associated_project = [ v if isinstance(v, ProjectId) else ProjectId(v) for v in self.associated_project ] if self.primary_disease_type is not None and not isinstance( self.primary_disease_type, CodeableConcept): self.primary_disease_type = CodeableConcept( **self.primary_disease_type) if self.primary_disease_site is not None and not isinstance( self.primary_disease_site, CodeableConcept): self.primary_disease_site = CodeableConcept( **self.primary_disease_site) if self.associated_patient is not None and not isinstance( self.associated_patient, PatientId): self.associated_patient = PatientId(self.associated_patient) 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 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 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: Optional[Union[Union[ElementIdentifier, BiosampleId], List[Union[ElementIdentifier, BiosampleId]]]] = empty_list() output: Optional[Union[Union[ElementIdentifier, BiosampleId], List[Union[ElementIdentifier, BiosampleId]]]] = empty_list() def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): if self.input is None: self.input = [] if not isinstance(self.input, list): self.input = [self.input] self.input = [v if isinstance(v, BiosampleId) else BiosampleId(v) for v in self.input] if self.output is None: self.output = [] if not isinstance(self.output, list): self.output = [self.output] self.output = [v if isinstance(v, BiosampleId) else BiosampleId(v) for v in self.output] super().__post_init__(**kwargs)
class GOLRField(YAMLRoot): id: str description: str display_name: str property: List = empty_list() cardinality: Optional[str] = None
class Characteristic(YAMLRoot): """ A characteristic of a biosample. Examples: depth, habitat, material, ... For NMDC, characteristics SHOULD be mapped to fields within a MIxS template """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = NMDC.Characteristic class_class_curie: ClassVar[str] = "nmdc:Characteristic" class_name: ClassVar[str] = "characteristic" class_model_uri: ClassVar[URIRef] = NMDC.Characteristic id: Union[ElementIdentifier, CharacteristicId] = None name: Optional[str] = None description: Optional[str] = None 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, CharacteristicId): self.id = CharacteristicId(self.id) if self.name is not None and not isinstance(self.name, str): self.name = str(self.name) if self.description is not None and not isinstance(self.description, str): self.description = str(self.description) 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 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)