# Auto generated from meta.yaml by pythongen.py version: 0.0.1
# Generation date: 2024-06-27T23:15:25
# Schema: meta
#
# id: https://w3id.org/linkml/meta
# description: The metamodel for schemas defined using the Linked Data Modeling Language framework.
#
# For more information on LinkML:
#
# * [linkml.io](https://linkml.io) main website
# * [specification](https://w3id.org/linkml/docs/specification/)
#
# LinkML is self-describing. Every LinkML schema consists of elements
# that instantiate classes in this metamodel.
#
# Core metaclasses:
#
# * [SchemaDefinition](https://w3id.org/linkml/SchemaDefinition)
# * [ClassDefinition](https://w3id.org/linkml/ClassDefinition)
# * [SlotDefinition](https://w3id.org/linkml/SlotDefinition)
# * [TypeDefinition](https://w3id.org/linkml/TypeDefinition)
#
# There are many subsets of *profiles* of the metamodel, for different purposes:
#
# * [MinimalSubset](https://w3id.org/linkml/MinimalSubset)
# * [BasicSubset](https://w3id.org/linkml/BasicSubset)
#
# For canonical reference documentation on any metamodel construct,
# refer to the official URI for each construct, e.g.
# [https://w3id.org/linkml/is_a](https://w3id.org/linkml/is_a)
# license: https://creativecommons.org/publicdomain/zero/1.0/
from dataclasses import dataclass
from typing import Any, ClassVar, Optional, Union
from jsonasobj2 import as_dict
from rdflib import URIRef
from linkml_runtime.utils.curienamespace import CurieNamespace
from linkml_runtime.utils.enumerations import EnumDefinitionImpl
from linkml_runtime.utils.formatutils import sfx
from linkml_runtime.utils.metamodelcore import URI, Bool, NCName, URIorCURIE, XSDDateTime, empty_dict, empty_list
from linkml_runtime.utils.slot import Slot
from linkml_runtime.utils.yamlutils import YAMLRoot, extended_str
from .annotations import Annotation, AnnotationTag
from .extensions import Extension, ExtensionTag
from .units import UnitOfMeasure
metamodel_version = "1.7.0"
version = None
# Namespaces
IAO = CurieNamespace("IAO", "http://purl.obolibrary.org/obo/IAO_")
NCIT = CurieNamespace("NCIT", "http://ncicb.nci.nih.gov/xml/owl/EVS/Thesaurus.owl#")
OIO = CurieNamespace("OIO", "http://www.geneontology.org/formats/oboInOwl#")
SIO = CurieNamespace("SIO", "http://semanticscience.org/resource/SIO_")
BIBO = CurieNamespace("bibo", "http://purl.org/ontology/bibo/")
CDISC = CurieNamespace("cdisc", "http://rdf.cdisc.org/mms#")
DCTERMS = CurieNamespace("dcterms", "http://purl.org/dc/terms/")
LINKML = CurieNamespace("linkml", "https://w3id.org/linkml/")
OSLC = CurieNamespace("oslc", "http://open-services.net/ns/core#")
OWL = CurieNamespace("owl", "http://www.w3.org/2002/07/owl#")
PAV = CurieNamespace("pav", "http://purl.org/pav/")
PROV = CurieNamespace("prov", "http://www.w3.org/ns/prov#")
QB = CurieNamespace("qb", "http://purl.org/linked-data/cube#")
QUDT = CurieNamespace("qudt", "http://qudt.org/schema/qudt/")
RDF = CurieNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
RDFS = CurieNamespace("rdfs", "http://www.w3.org/2000/01/rdf-schema#")
SCHEMA = CurieNamespace("schema", "http://schema.org/")
SH = CurieNamespace("sh", "http://www.w3.org/ns/shacl#")
SKOS = CurieNamespace("skos", "http://www.w3.org/2004/02/skos/core#")
SKOSXL = CurieNamespace("skosxl", "http://www.w3.org/2008/05/skos-xl#")
SWRL = CurieNamespace("swrl", "http://www.w3.org/2003/11/swrl#")
VANN = CurieNamespace("vann", "https://vocab.org/vann/")
XSD = CurieNamespace("xsd", "http://www.w3.org/2001/XMLSchema#")
DEFAULT_ = LINKML
# Types
# Class references
class ElementName(extended_str):
pass
class SchemaDefinitionName(NCName):
pass
class TypeDefinitionName(ElementName):
pass
class SubsetDefinitionName(ElementName):
pass
class DefinitionName(ElementName):
pass
class EnumDefinitionName(DefinitionName):
pass
class SlotDefinitionName(DefinitionName):
pass
class ClassDefinitionName(DefinitionName):
pass
class SettingSettingKey(NCName):
pass
class PrefixPrefixPrefix(NCName):
pass
class LocalNameLocalNameSource(NCName):
pass
class AltDescriptionSource(extended_str):
pass
class PermissibleValueText(extended_str):
pass
class UniqueKeyUniqueKeyName(extended_str):
pass
class TypeMappingFramework(extended_str):
pass
Anything = Any
@dataclass(repr=False)
class CommonMetadata(YAMLRoot):
"""
Generic metadata shared across definitions
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["CommonMetadata"]
class_class_curie: ClassVar[str] = "linkml:CommonMetadata"
class_name: ClassVar[str] = "common_metadata"
class_model_uri: ClassVar[URIRef] = LINKML.CommonMetadata
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, "StructuredAlias"], list[Union[dict, "StructuredAlias"]]]] = (
empty_list()
)
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Element(YAMLRoot):
"""
A named element in the model
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["Element"]
class_class_curie: ClassVar[str] = "linkml:Element"
class_name: ClassVar[str] = "element"
class_model_uri: ClassVar[URIRef] = LINKML.Element
name: Union[str, ElementName] = None
id_prefixes: Optional[Union[Union[str, NCName], list[Union[str, NCName]]]] = empty_list()
id_prefixes_are_closed: Optional[Union[bool, Bool]] = None
definition_uri: Optional[Union[str, URIorCURIE]] = None
local_names: Optional[
Union[dict[Union[str, LocalNameLocalNameSource], Union[dict, "LocalName"]], list[Union[dict, "LocalName"]]]
] = empty_dict()
conforms_to: Optional[str] = None
implements: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
instantiates: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, "StructuredAlias"], list[Union[dict, "StructuredAlias"]]]] = (
empty_list()
)
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, ElementName):
self.name = ElementName(self.name)
if not isinstance(self.id_prefixes, list):
self.id_prefixes = [self.id_prefixes] if self.id_prefixes is not None else []
self.id_prefixes = [v if isinstance(v, NCName) else NCName(v) for v in self.id_prefixes]
if self.id_prefixes_are_closed is not None and not isinstance(self.id_prefixes_are_closed, Bool):
self.id_prefixes_are_closed = Bool(self.id_prefixes_are_closed)
if self.definition_uri is not None and not isinstance(self.definition_uri, URIorCURIE):
self.definition_uri = URIorCURIE(self.definition_uri)
self._normalize_inlined_as_dict(
slot_name="local_names", slot_type=LocalName, key_name="local_name_source", keyed=True
)
if self.conforms_to is not None and not isinstance(self.conforms_to, str):
self.conforms_to = str(self.conforms_to)
if not isinstance(self.implements, list):
self.implements = [self.implements] if self.implements is not None else []
self.implements = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.implements]
if not isinstance(self.instantiates, list):
self.instantiates = [self.instantiates] if self.instantiates is not None else []
self.instantiates = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.instantiates]
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class SchemaDefinition(Element):
"""
A collection of definitions that make up a schema or a data model.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["SchemaDefinition"]
class_class_curie: ClassVar[str] = "linkml:SchemaDefinition"
class_name: ClassVar[str] = "schema_definition"
class_model_uri: ClassVar[URIRef] = LINKML.SchemaDefinition
name: Union[str, SchemaDefinitionName] = None
id: Union[str, URI] = None
version: Optional[str] = None
imports: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
license: Optional[str] = None
prefixes: Optional[
Union[dict[Union[str, PrefixPrefixPrefix], Union[dict, "Prefix"]], list[Union[dict, "Prefix"]]]
] = empty_dict()
emit_prefixes: Optional[Union[Union[str, NCName], list[Union[str, NCName]]]] = empty_list()
default_curi_maps: Optional[Union[str, list[str]]] = empty_list()
default_prefix: Optional[str] = None
default_range: Optional[Union[str, TypeDefinitionName]] = None
subsets: Optional[
Union[
dict[Union[str, SubsetDefinitionName], Union[dict, "SubsetDefinition"]],
list[Union[dict, "SubsetDefinition"]],
]
] = empty_dict()
types: Optional[
Union[dict[Union[str, TypeDefinitionName], Union[dict, "TypeDefinition"]], list[Union[dict, "TypeDefinition"]]]
] = empty_dict()
enums: Optional[
Union[dict[Union[str, EnumDefinitionName], Union[dict, "EnumDefinition"]], list[Union[dict, "EnumDefinition"]]]
] = empty_dict()
slots: Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, "SlotDefinition"]], list[Union[dict, "SlotDefinition"]]]
] = empty_dict()
classes: Optional[
Union[
dict[Union[str, ClassDefinitionName], Union[dict, "ClassDefinition"]], list[Union[dict, "ClassDefinition"]]
]
] = empty_dict()
metamodel_version: Optional[str] = None
source_file: Optional[str] = None
source_file_date: Optional[Union[str, XSDDateTime]] = None
source_file_size: Optional[int] = None
generation_date: Optional[Union[str, XSDDateTime]] = None
slot_names_unique: Optional[Union[bool, Bool]] = None
settings: Optional[
Union[dict[Union[str, SettingSettingKey], Union[dict, "Setting"]], list[Union[dict, "Setting"]]]
] = empty_dict()
bindings: Optional[Union[Union[dict, "EnumBinding"], list[Union[dict, "EnumBinding"]]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.default_prefix is None:
self.default_prefix = sfx(str(self.id))
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, SchemaDefinitionName):
self.name = SchemaDefinitionName(self.name)
if self._is_empty(self.id):
self.MissingRequiredField("id")
if not isinstance(self.id, URI):
self.id = URI(self.id)
if self.version is not None and not isinstance(self.version, str):
self.version = str(self.version)
if not isinstance(self.imports, list):
self.imports = [self.imports] if self.imports is not None else []
self.imports = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.imports]
if self.license is not None and not isinstance(self.license, str):
self.license = str(self.license)
self._normalize_inlined_as_dict(slot_name="prefixes", slot_type=Prefix, key_name="prefix_prefix", keyed=True)
if not isinstance(self.emit_prefixes, list):
self.emit_prefixes = [self.emit_prefixes] if self.emit_prefixes is not None else []
self.emit_prefixes = [v if isinstance(v, NCName) else NCName(v) for v in self.emit_prefixes]
if not isinstance(self.default_curi_maps, list):
self.default_curi_maps = [self.default_curi_maps] if self.default_curi_maps is not None else []
self.default_curi_maps = [v if isinstance(v, str) else str(v) for v in self.default_curi_maps]
if self.default_prefix is not None and not isinstance(self.default_prefix, str):
self.default_prefix = str(self.default_prefix)
if self.default_range is not None and not isinstance(self.default_range, TypeDefinitionName):
self.default_range = TypeDefinitionName(self.default_range)
self._normalize_inlined_as_dict(slot_name="subsets", slot_type=SubsetDefinition, key_name="name", keyed=True)
self._normalize_inlined_as_dict(slot_name="types", slot_type=TypeDefinition, key_name="name", keyed=True)
self._normalize_inlined_as_dict(slot_name="enums", slot_type=EnumDefinition, key_name="name", keyed=True)
self._normalize_inlined_as_dict(slot_name="slots", slot_type=SlotDefinition, key_name="name", keyed=True)
self._normalize_inlined_as_dict(slot_name="classes", slot_type=ClassDefinition, key_name="name", keyed=True)
if self.metamodel_version is not None and not isinstance(self.metamodel_version, str):
self.metamodel_version = str(self.metamodel_version)
if self.source_file is not None and not isinstance(self.source_file, str):
self.source_file = str(self.source_file)
if self.source_file_date is not None and not isinstance(self.source_file_date, XSDDateTime):
self.source_file_date = XSDDateTime(self.source_file_date)
if self.source_file_size is not None and not isinstance(self.source_file_size, int):
self.source_file_size = int(self.source_file_size)
if self.generation_date is not None and not isinstance(self.generation_date, XSDDateTime):
self.generation_date = XSDDateTime(self.generation_date)
if self.slot_names_unique is not None and not isinstance(self.slot_names_unique, Bool):
self.slot_names_unique = Bool(self.slot_names_unique)
self._normalize_inlined_as_dict(slot_name="settings", slot_type=Setting, key_name="setting_key", keyed=True)
if not isinstance(self.bindings, list):
self.bindings = [self.bindings] if self.bindings is not None else []
self.bindings = [v if isinstance(v, EnumBinding) else EnumBinding(**as_dict(v)) for v in self.bindings]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class AnonymousTypeExpression(YAMLRoot):
"""
A type expression that is not a top-level named type definition. Used for nesting.
"""
_inherited_slots: ClassVar[list[str]] = [
"pattern",
"structured_pattern",
"equals_string",
"equals_string_in",
"equals_number",
"minimum_value",
"maximum_value",
]
class_class_uri: ClassVar[URIRef] = LINKML["AnonymousTypeExpression"]
class_class_curie: ClassVar[str] = "linkml:AnonymousTypeExpression"
class_name: ClassVar[str] = "anonymous_type_expression"
class_model_uri: ClassVar[URIRef] = LINKML.AnonymousTypeExpression
pattern: Optional[str] = None
structured_pattern: Optional[Union[dict, "PatternExpression"]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
implicit_prefix: Optional[str] = None
equals_string: Optional[str] = None
equals_string_in: Optional[Union[str, list[str]]] = empty_list()
equals_number: Optional[int] = None
minimum_value: Optional[Union[dict, Anything]] = None
maximum_value: Optional[Union[dict, Anything]] = None
none_of: Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]
] = empty_list()
any_of: Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]] = (
empty_list()
)
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.pattern is not None and not isinstance(self.pattern, str):
self.pattern = str(self.pattern)
if self.structured_pattern is not None and not isinstance(self.structured_pattern, PatternExpression):
self.structured_pattern = PatternExpression(**as_dict(self.structured_pattern))
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if self.implicit_prefix is not None and not isinstance(self.implicit_prefix, str):
self.implicit_prefix = str(self.implicit_prefix)
if self.equals_string is not None and not isinstance(self.equals_string, str):
self.equals_string = str(self.equals_string)
if not isinstance(self.equals_string_in, list):
self.equals_string_in = [self.equals_string_in] if self.equals_string_in is not None else []
self.equals_string_in = [v if isinstance(v, str) else str(v) for v in self.equals_string_in]
if self.equals_number is not None and not isinstance(self.equals_number, int):
self.equals_number = int(self.equals_number)
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.none_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.any_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.all_of
]
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class TypeDefinition(Element):
"""
an element that whose instances are atomic scalar values that can be mapped to primitive types
"""
_inherited_slots: ClassVar[list[str]] = [
"base",
"uri",
"repr",
"pattern",
"structured_pattern",
"equals_string",
"equals_string_in",
"equals_number",
"minimum_value",
"maximum_value",
]
class_class_uri: ClassVar[URIRef] = LINKML["TypeDefinition"]
class_class_curie: ClassVar[str] = "linkml:TypeDefinition"
class_name: ClassVar[str] = "type_definition"
class_model_uri: ClassVar[URIRef] = LINKML.TypeDefinition
name: Union[str, TypeDefinitionName] = None
typeof: Optional[Union[str, TypeDefinitionName]] = None
base: Optional[str] = None
uri: Optional[Union[str, URIorCURIE]] = None
repr: Optional[str] = None
union_of: Optional[Union[Union[str, TypeDefinitionName], list[Union[str, TypeDefinitionName]]]] = empty_list()
pattern: Optional[str] = None
structured_pattern: Optional[Union[dict, "PatternExpression"]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
implicit_prefix: Optional[str] = None
equals_string: Optional[str] = None
equals_string_in: Optional[Union[str, list[str]]] = empty_list()
equals_number: Optional[int] = None
minimum_value: Optional[Union[dict, Anything]] = None
maximum_value: Optional[Union[dict, Anything]] = None
none_of: Optional[Union[Union[dict, AnonymousTypeExpression], list[Union[dict, AnonymousTypeExpression]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, AnonymousTypeExpression], list[Union[dict, AnonymousTypeExpression]]]
] = empty_list()
any_of: Optional[Union[Union[dict, AnonymousTypeExpression], list[Union[dict, AnonymousTypeExpression]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, AnonymousTypeExpression], list[Union[dict, AnonymousTypeExpression]]]] = (
empty_list()
)
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.name):
self.MissingRequiredField("name")
if 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.base is not None and not isinstance(self.base, str):
self.base = str(self.base)
if self.uri is not None and not isinstance(self.uri, URIorCURIE):
self.uri = URIorCURIE(self.uri)
if self.repr is not None and not isinstance(self.repr, str):
self.repr = str(self.repr)
if not isinstance(self.union_of, list):
self.union_of = [self.union_of] if self.union_of is not None else []
self.union_of = [v if isinstance(v, TypeDefinitionName) else TypeDefinitionName(v) for v in self.union_of]
if self.pattern is not None and not isinstance(self.pattern, str):
self.pattern = str(self.pattern)
if self.structured_pattern is not None and not isinstance(self.structured_pattern, PatternExpression):
self.structured_pattern = PatternExpression(**as_dict(self.structured_pattern))
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if self.implicit_prefix is not None and not isinstance(self.implicit_prefix, str):
self.implicit_prefix = str(self.implicit_prefix)
if self.equals_string is not None and not isinstance(self.equals_string, str):
self.equals_string = str(self.equals_string)
if not isinstance(self.equals_string_in, list):
self.equals_string_in = [self.equals_string_in] if self.equals_string_in is not None else []
self.equals_string_in = [v if isinstance(v, str) else str(v) for v in self.equals_string_in]
if self.equals_number is not None and not isinstance(self.equals_number, int):
self.equals_number = int(self.equals_number)
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.none_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.any_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.all_of
]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class SubsetDefinition(Element):
"""
an element that can be used to group other metamodel elements
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["SubsetDefinition"]
class_class_curie: ClassVar[str] = "linkml:SubsetDefinition"
class_name: ClassVar[str] = "subset_definition"
class_model_uri: ClassVar[URIRef] = LINKML.SubsetDefinition
name: Union[str, SubsetDefinitionName] = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, SubsetDefinitionName):
self.name = SubsetDefinitionName(self.name)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Definition(Element):
"""
abstract base class for core metaclasses
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["Definition"]
class_class_curie: ClassVar[str] = "linkml:Definition"
class_name: ClassVar[str] = "definition"
class_model_uri: ClassVar[URIRef] = LINKML.Definition
name: Union[str, DefinitionName] = None
is_a: Optional[Union[str, DefinitionName]] = None
abstract: Optional[Union[bool, Bool]] = None
mixin: Optional[Union[bool, Bool]] = None
mixins: Optional[Union[Union[str, DefinitionName], list[Union[str, DefinitionName]]]] = empty_list()
apply_to: Optional[Union[Union[str, DefinitionName], list[Union[str, DefinitionName]]]] = empty_list()
values_from: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
string_serialization: Optional[str] = None
def __post_init__(self, *_: list[str], **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)
if self.abstract is not None and not isinstance(self.abstract, Bool):
self.abstract = Bool(self.abstract)
if self.mixin is not None and not isinstance(self.mixin, Bool):
self.mixin = Bool(self.mixin)
if not isinstance(self.mixins, list):
self.mixins = [self.mixins] if self.mixins is not None else []
self.mixins = [v if isinstance(v, DefinitionName) else DefinitionName(v) for v in self.mixins]
if not isinstance(self.apply_to, list):
self.apply_to = [self.apply_to] if self.apply_to is not None else []
self.apply_to = [v if isinstance(v, DefinitionName) else DefinitionName(v) for v in self.apply_to]
if not isinstance(self.values_from, list):
self.values_from = [self.values_from] if self.values_from is not None else []
self.values_from = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.values_from]
if self.string_serialization is not None and not isinstance(self.string_serialization, str):
self.string_serialization = str(self.string_serialization)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class AnonymousEnumExpression(YAMLRoot):
"""
An enum_expression that is not named
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["AnonymousEnumExpression"]
class_class_curie: ClassVar[str] = "linkml:AnonymousEnumExpression"
class_name: ClassVar[str] = "anonymous_enum_expression"
class_model_uri: ClassVar[URIRef] = LINKML.AnonymousEnumExpression
code_set: Optional[Union[str, URIorCURIE]] = None
code_set_tag: Optional[str] = None
code_set_version: Optional[str] = None
pv_formula: Optional[Union[str, "PvFormulaOptions"]] = None
permissible_values: Optional[
Union[
dict[Union[str, PermissibleValueText], Union[dict, "PermissibleValue"]],
list[Union[dict, "PermissibleValue"]],
]
] = empty_dict()
include: Optional[Union[Union[dict, "AnonymousEnumExpression"], list[Union[dict, "AnonymousEnumExpression"]]]] = (
empty_list()
)
minus: Optional[Union[Union[dict, "AnonymousEnumExpression"], list[Union[dict, "AnonymousEnumExpression"]]]] = (
empty_list()
)
inherits: Optional[Union[Union[str, EnumDefinitionName], list[Union[str, EnumDefinitionName]]]] = empty_list()
reachable_from: Optional[Union[dict, "ReachabilityQuery"]] = None
matches: Optional[Union[dict, "MatchQuery"]] = None
concepts: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.code_set is not None and not isinstance(self.code_set, URIorCURIE):
self.code_set = URIorCURIE(self.code_set)
if self.code_set_tag is not None and not isinstance(self.code_set_tag, str):
self.code_set_tag = str(self.code_set_tag)
if self.code_set_version is not None and not isinstance(self.code_set_version, str):
self.code_set_version = str(self.code_set_version)
if self.pv_formula is not None and not isinstance(self.pv_formula, PvFormulaOptions):
self.pv_formula = PvFormulaOptions(self.pv_formula)
self._normalize_inlined_as_dict(
slot_name="permissible_values", slot_type=PermissibleValue, key_name="text", keyed=True
)
if not isinstance(self.include, list):
self.include = [self.include] if self.include is not None else []
self.include = [
v if isinstance(v, AnonymousEnumExpression) else AnonymousEnumExpression(**as_dict(v)) for v in self.include
]
if not isinstance(self.minus, list):
self.minus = [self.minus] if self.minus is not None else []
self.minus = [
v if isinstance(v, AnonymousEnumExpression) else AnonymousEnumExpression(**as_dict(v)) for v in self.minus
]
if not isinstance(self.inherits, list):
self.inherits = [self.inherits] if self.inherits is not None else []
self.inherits = [v if isinstance(v, EnumDefinitionName) else EnumDefinitionName(v) for v in self.inherits]
if self.reachable_from is not None and not isinstance(self.reachable_from, ReachabilityQuery):
self.reachable_from = ReachabilityQuery(**as_dict(self.reachable_from))
if self.matches is not None and not isinstance(self.matches, MatchQuery):
self.matches = MatchQuery(**as_dict(self.matches))
if not isinstance(self.concepts, list):
self.concepts = [self.concepts] if self.concepts is not None else []
self.concepts = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.concepts]
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class EnumDefinition(Definition):
"""
an element whose instances must be drawn from a specified set of permissible values
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["EnumDefinition"]
class_class_curie: ClassVar[str] = "linkml:EnumDefinition"
class_name: ClassVar[str] = "enum_definition"
class_model_uri: ClassVar[URIRef] = LINKML.EnumDefinition
name: Union[str, EnumDefinitionName] = None
enum_uri: Optional[Union[str, URIorCURIE]] = None
code_set: Optional[Union[str, URIorCURIE]] = None
code_set_tag: Optional[str] = None
code_set_version: Optional[str] = None
pv_formula: Optional[Union[str, "PvFormulaOptions"]] = None
permissible_values: Optional[
Union[
dict[Union[str, PermissibleValueText], Union[dict, "PermissibleValue"]],
list[Union[dict, "PermissibleValue"]],
]
] = empty_dict()
include: Optional[Union[Union[dict, AnonymousEnumExpression], list[Union[dict, AnonymousEnumExpression]]]] = (
empty_list()
)
minus: Optional[Union[Union[dict, AnonymousEnumExpression], list[Union[dict, AnonymousEnumExpression]]]] = (
empty_list()
)
inherits: Optional[Union[Union[str, EnumDefinitionName], list[Union[str, EnumDefinitionName]]]] = empty_list()
reachable_from: Optional[Union[dict, "ReachabilityQuery"]] = None
matches: Optional[Union[dict, "MatchQuery"]] = None
concepts: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, EnumDefinitionName):
self.name = EnumDefinitionName(self.name)
if self.enum_uri is not None and not isinstance(self.enum_uri, URIorCURIE):
self.enum_uri = URIorCURIE(self.enum_uri)
if self.code_set is not None and not isinstance(self.code_set, URIorCURIE):
self.code_set = URIorCURIE(self.code_set)
if self.code_set_tag is not None and not isinstance(self.code_set_tag, str):
self.code_set_tag = str(self.code_set_tag)
if self.code_set_version is not None and not isinstance(self.code_set_version, str):
self.code_set_version = str(self.code_set_version)
if self.pv_formula is not None and not isinstance(self.pv_formula, PvFormulaOptions):
self.pv_formula = PvFormulaOptions(self.pv_formula)
self._normalize_inlined_as_dict(
slot_name="permissible_values", slot_type=PermissibleValue, key_name="text", keyed=True
)
if not isinstance(self.include, list):
self.include = [self.include] if self.include is not None else []
self.include = [
v if isinstance(v, AnonymousEnumExpression) else AnonymousEnumExpression(**as_dict(v)) for v in self.include
]
if not isinstance(self.minus, list):
self.minus = [self.minus] if self.minus is not None else []
self.minus = [
v if isinstance(v, AnonymousEnumExpression) else AnonymousEnumExpression(**as_dict(v)) for v in self.minus
]
if not isinstance(self.inherits, list):
self.inherits = [self.inherits] if self.inherits is not None else []
self.inherits = [v if isinstance(v, EnumDefinitionName) else EnumDefinitionName(v) for v in self.inherits]
if self.reachable_from is not None and not isinstance(self.reachable_from, ReachabilityQuery):
self.reachable_from = ReachabilityQuery(**as_dict(self.reachable_from))
if self.matches is not None and not isinstance(self.matches, MatchQuery):
self.matches = MatchQuery(**as_dict(self.matches))
if not isinstance(self.concepts, list):
self.concepts = [self.concepts] if self.concepts is not None else []
self.concepts = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.concepts]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class EnumBinding(YAMLRoot):
"""
A binding of a slot or a class to a permissible value from an enumeration.
"""
_inherited_slots: ClassVar[list[str]] = ["range"]
class_class_uri: ClassVar[URIRef] = LINKML["EnumBinding"]
class_class_curie: ClassVar[str] = "linkml:EnumBinding"
class_name: ClassVar[str] = "enum_binding"
class_model_uri: ClassVar[URIRef] = LINKML.EnumBinding
range: Optional[Union[str, EnumDefinitionName]] = None
obligation_level: Optional[Union[str, "ObligationLevelEnum"]] = None
binds_value_of: Optional[str] = None
pv_formula: Optional[Union[str, "PvFormulaOptions"]] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, "StructuredAlias"], list[Union[dict, "StructuredAlias"]]]] = (
empty_list()
)
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.range is not None and not isinstance(self.range, EnumDefinitionName):
self.range = EnumDefinitionName(self.range)
if self.obligation_level is not None and not isinstance(self.obligation_level, ObligationLevelEnum):
self.obligation_level = ObligationLevelEnum(self.obligation_level)
if self.binds_value_of is not None and not isinstance(self.binds_value_of, str):
self.binds_value_of = str(self.binds_value_of)
if self.pv_formula is not None and not isinstance(self.pv_formula, PvFormulaOptions):
self.pv_formula = PvFormulaOptions(self.pv_formula)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class MatchQuery(YAMLRoot):
"""
A query that is used on an enum expression to dynamically obtain a set of permissivle values via a query that
matches on properties of the external concepts.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["MatchQuery"]
class_class_curie: ClassVar[str] = "linkml:MatchQuery"
class_name: ClassVar[str] = "match_query"
class_model_uri: ClassVar[URIRef] = LINKML.MatchQuery
identifier_pattern: Optional[str] = None
source_ontology: Optional[Union[str, URIorCURIE]] = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.identifier_pattern is not None and not isinstance(self.identifier_pattern, str):
self.identifier_pattern = str(self.identifier_pattern)
if self.source_ontology is not None and not isinstance(self.source_ontology, URIorCURIE):
self.source_ontology = URIorCURIE(self.source_ontology)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class ReachabilityQuery(YAMLRoot):
"""
A query that is used on an enum expression to dynamically obtain a set of permissible values via walking from a
set of source nodes to a set of descendants or ancestors over a set of relationship types.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["ReachabilityQuery"]
class_class_curie: ClassVar[str] = "linkml:ReachabilityQuery"
class_name: ClassVar[str] = "reachability_query"
class_model_uri: ClassVar[URIRef] = LINKML.ReachabilityQuery
source_ontology: Optional[Union[str, URIorCURIE]] = None
source_nodes: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
relationship_types: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
is_direct: Optional[Union[bool, Bool]] = None
include_self: Optional[Union[bool, Bool]] = None
traverse_up: Optional[Union[bool, Bool]] = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.source_ontology is not None and not isinstance(self.source_ontology, URIorCURIE):
self.source_ontology = URIorCURIE(self.source_ontology)
if not isinstance(self.source_nodes, list):
self.source_nodes = [self.source_nodes] if self.source_nodes is not None else []
self.source_nodes = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.source_nodes]
if not isinstance(self.relationship_types, list):
self.relationship_types = [self.relationship_types] if self.relationship_types is not None else []
self.relationship_types = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.relationship_types]
if self.is_direct is not None and not isinstance(self.is_direct, Bool):
self.is_direct = Bool(self.is_direct)
if self.include_self is not None and not isinstance(self.include_self, Bool):
self.include_self = Bool(self.include_self)
if self.traverse_up is not None and not isinstance(self.traverse_up, Bool):
self.traverse_up = Bool(self.traverse_up)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class StructuredAlias(YAMLRoot):
"""
object that contains meta data about a synonym or alias including where it came from (source) and its scope
(narrow, broad, etc.)
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = SKOSXL["Label"]
class_class_curie: ClassVar[str] = "skosxl:Label"
class_name: ClassVar[str] = "structured_alias"
class_model_uri: ClassVar[URIRef] = LINKML.StructuredAlias
literal_form: str = None
predicate: Optional[Union[str, "AliasPredicateEnum"]] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
contexts: Optional[Union[Union[str, URI], list[Union[str, URI]]]] = empty_list()
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, "StructuredAlias"], list[Union[dict, "StructuredAlias"]]]] = (
empty_list()
)
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.literal_form):
self.MissingRequiredField("literal_form")
if not isinstance(self.literal_form, str):
self.literal_form = str(self.literal_form)
if self.predicate is not None and not isinstance(self.predicate, AliasPredicateEnum):
self.predicate = AliasPredicateEnum(self.predicate)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.contexts, list):
self.contexts = [self.contexts] if self.contexts is not None else []
self.contexts = [v if isinstance(v, URI) else URI(v) for v in self.contexts]
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
class Expression(YAMLRoot):
"""
general mixin for any class that can represent some form of expression
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["Expression"]
class_class_curie: ClassVar[str] = "linkml:Expression"
class_name: ClassVar[str] = "expression"
class_model_uri: ClassVar[URIRef] = LINKML.Expression
@dataclass(repr=False)
class TypeExpression(Expression):
"""
An abstract class grouping named types and anonymous type expressions
"""
_inherited_slots: ClassVar[list[str]] = [
"pattern",
"structured_pattern",
"equals_string",
"equals_string_in",
"equals_number",
"minimum_value",
"maximum_value",
]
class_class_uri: ClassVar[URIRef] = LINKML["TypeExpression"]
class_class_curie: ClassVar[str] = "linkml:TypeExpression"
class_name: ClassVar[str] = "type_expression"
class_model_uri: ClassVar[URIRef] = LINKML.TypeExpression
pattern: Optional[str] = None
structured_pattern: Optional[Union[dict, "PatternExpression"]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
implicit_prefix: Optional[str] = None
equals_string: Optional[str] = None
equals_string_in: Optional[Union[str, list[str]]] = empty_list()
equals_number: Optional[int] = None
minimum_value: Optional[Union[dict, Anything]] = None
maximum_value: Optional[Union[dict, Anything]] = None
none_of: Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]
] = empty_list()
any_of: Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]] = (
empty_list()
)
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.pattern is not None and not isinstance(self.pattern, str):
self.pattern = str(self.pattern)
if self.structured_pattern is not None and not isinstance(self.structured_pattern, PatternExpression):
self.structured_pattern = PatternExpression(**as_dict(self.structured_pattern))
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if self.implicit_prefix is not None and not isinstance(self.implicit_prefix, str):
self.implicit_prefix = str(self.implicit_prefix)
if self.equals_string is not None and not isinstance(self.equals_string, str):
self.equals_string = str(self.equals_string)
if not isinstance(self.equals_string_in, list):
self.equals_string_in = [self.equals_string_in] if self.equals_string_in is not None else []
self.equals_string_in = [v if isinstance(v, str) else str(v) for v in self.equals_string_in]
if self.equals_number is not None and not isinstance(self.equals_number, int):
self.equals_number = int(self.equals_number)
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.none_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.any_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousTypeExpression) else AnonymousTypeExpression(**as_dict(v)) for v in self.all_of
]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class EnumExpression(Expression):
"""
An expression that constrains the range of a slot
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["EnumExpression"]
class_class_curie: ClassVar[str] = "linkml:EnumExpression"
class_name: ClassVar[str] = "enum_expression"
class_model_uri: ClassVar[URIRef] = LINKML.EnumExpression
code_set: Optional[Union[str, URIorCURIE]] = None
code_set_tag: Optional[str] = None
code_set_version: Optional[str] = None
pv_formula: Optional[Union[str, "PvFormulaOptions"]] = None
permissible_values: Optional[
Union[
dict[Union[str, PermissibleValueText], Union[dict, "PermissibleValue"]],
list[Union[dict, "PermissibleValue"]],
]
] = empty_dict()
include: Optional[Union[Union[dict, "AnonymousEnumExpression"], list[Union[dict, "AnonymousEnumExpression"]]]] = (
empty_list()
)
minus: Optional[Union[Union[dict, "AnonymousEnumExpression"], list[Union[dict, "AnonymousEnumExpression"]]]] = (
empty_list()
)
inherits: Optional[Union[Union[str, EnumDefinitionName], list[Union[str, EnumDefinitionName]]]] = empty_list()
reachable_from: Optional[Union[dict, "ReachabilityQuery"]] = None
matches: Optional[Union[dict, "MatchQuery"]] = None
concepts: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.code_set is not None and not isinstance(self.code_set, URIorCURIE):
self.code_set = URIorCURIE(self.code_set)
if self.code_set_tag is not None and not isinstance(self.code_set_tag, str):
self.code_set_tag = str(self.code_set_tag)
if self.code_set_version is not None and not isinstance(self.code_set_version, str):
self.code_set_version = str(self.code_set_version)
if self.pv_formula is not None and not isinstance(self.pv_formula, PvFormulaOptions):
self.pv_formula = PvFormulaOptions(self.pv_formula)
self._normalize_inlined_as_dict(
slot_name="permissible_values", slot_type=PermissibleValue, key_name="text", keyed=True
)
if not isinstance(self.include, list):
self.include = [self.include] if self.include is not None else []
self.include = [
v if isinstance(v, AnonymousEnumExpression) else AnonymousEnumExpression(**as_dict(v)) for v in self.include
]
if not isinstance(self.minus, list):
self.minus = [self.minus] if self.minus is not None else []
self.minus = [
v if isinstance(v, AnonymousEnumExpression) else AnonymousEnumExpression(**as_dict(v)) for v in self.minus
]
if not isinstance(self.inherits, list):
self.inherits = [self.inherits] if self.inherits is not None else []
self.inherits = [v if isinstance(v, EnumDefinitionName) else EnumDefinitionName(v) for v in self.inherits]
if self.reachable_from is not None and not isinstance(self.reachable_from, ReachabilityQuery):
self.reachable_from = ReachabilityQuery(**as_dict(self.reachable_from))
if self.matches is not None and not isinstance(self.matches, MatchQuery):
self.matches = MatchQuery(**as_dict(self.matches))
if not isinstance(self.concepts, list):
self.concepts = [self.concepts] if self.concepts is not None else []
self.concepts = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.concepts]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class AnonymousExpression(YAMLRoot):
"""
An abstract parent class for any nested expression
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["AnonymousExpression"]
class_class_curie: ClassVar[str] = "linkml:AnonymousExpression"
class_name: ClassVar[str] = "anonymous_expression"
class_model_uri: ClassVar[URIRef] = LINKML.AnonymousExpression
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class PathExpression(YAMLRoot):
"""
An expression that describes an abstract path from an object to another through a sequence of slot lookups
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["PathExpression"]
class_class_curie: ClassVar[str] = "linkml:PathExpression"
class_name: ClassVar[str] = "path_expression"
class_model_uri: ClassVar[URIRef] = LINKML.PathExpression
followed_by: Optional[Union[dict, "PathExpression"]] = None
none_of: Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]] = empty_list()
any_of: Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]] = empty_list()
all_of: Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]] = empty_list()
exactly_one_of: Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]] = empty_list()
reversed: Optional[Union[bool, Bool]] = None
traverse: Optional[Union[str, SlotDefinitionName]] = None
range_expression: Optional[Union[dict, "AnonymousClassExpression"]] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.followed_by is not None and not isinstance(self.followed_by, PathExpression):
self.followed_by = PathExpression(**as_dict(self.followed_by))
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [v if isinstance(v, PathExpression) else PathExpression(**as_dict(v)) for v in self.none_of]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [v if isinstance(v, PathExpression) else PathExpression(**as_dict(v)) for v in self.any_of]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [v if isinstance(v, PathExpression) else PathExpression(**as_dict(v)) for v in self.all_of]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, PathExpression) else PathExpression(**as_dict(v)) for v in self.exactly_one_of
]
if self.reversed is not None and not isinstance(self.reversed, Bool):
self.reversed = Bool(self.reversed)
if self.traverse is not None and not isinstance(self.traverse, SlotDefinitionName):
self.traverse = SlotDefinitionName(self.traverse)
if self.range_expression is not None and not isinstance(self.range_expression, AnonymousClassExpression):
self.range_expression = AnonymousClassExpression(**as_dict(self.range_expression))
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class SlotExpression(Expression):
"""
an expression that constrains the range of values a slot can take
"""
_inherited_slots: ClassVar[list[str]] = [
"range",
"required",
"recommended",
"multivalued",
"inlined",
"inlined_as_list",
"minimum_value",
"maximum_value",
"pattern",
"structured_pattern",
"value_presence",
"equals_string",
"equals_string_in",
"equals_number",
"equals_expression",
"exact_cardinality",
"minimum_cardinality",
"maximum_cardinality",
]
class_class_uri: ClassVar[URIRef] = LINKML["SlotExpression"]
class_class_curie: ClassVar[str] = "linkml:SlotExpression"
class_name: ClassVar[str] = "slot_expression"
class_model_uri: ClassVar[URIRef] = LINKML.SlotExpression
range: Optional[Union[str, ElementName]] = None
range_expression: Optional[Union[dict, "AnonymousClassExpression"]] = None
enum_range: Optional[Union[dict, EnumExpression]] = None
bindings: Optional[Union[Union[dict, EnumBinding], list[Union[dict, EnumBinding]]]] = empty_list()
required: Optional[Union[bool, Bool]] = None
recommended: Optional[Union[bool, Bool]] = None
multivalued: Optional[Union[bool, Bool]] = None
inlined: Optional[Union[bool, Bool]] = None
inlined_as_list: Optional[Union[bool, Bool]] = None
minimum_value: Optional[Union[dict, Anything]] = None
maximum_value: Optional[Union[dict, Anything]] = None
pattern: Optional[str] = None
structured_pattern: Optional[Union[dict, "PatternExpression"]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
implicit_prefix: Optional[str] = None
value_presence: Optional[Union[str, "PresenceEnum"]] = None
equals_string: Optional[str] = None
equals_string_in: Optional[Union[str, list[str]]] = empty_list()
equals_number: Optional[int] = None
equals_expression: Optional[str] = None
exact_cardinality: Optional[int] = None
minimum_cardinality: Optional[int] = None
maximum_cardinality: Optional[int] = None
has_member: Optional[Union[dict, "AnonymousSlotExpression"]] = None
all_members: Optional[Union[dict, "AnonymousSlotExpression"]] = None
none_of: Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]
] = empty_list()
any_of: Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]] = (
empty_list()
)
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.range is not None and not isinstance(self.range, ElementName):
self.range = ElementName(self.range)
if self.range_expression is not None and not isinstance(self.range_expression, AnonymousClassExpression):
self.range_expression = AnonymousClassExpression(**as_dict(self.range_expression))
if self.enum_range is not None and not isinstance(self.enum_range, EnumExpression):
self.enum_range = EnumExpression(**as_dict(self.enum_range))
if not isinstance(self.bindings, list):
self.bindings = [self.bindings] if self.bindings is not None else []
self.bindings = [v if isinstance(v, EnumBinding) else EnumBinding(**as_dict(v)) for v in self.bindings]
if self.required is not None and not isinstance(self.required, Bool):
self.required = Bool(self.required)
if self.recommended is not None and not isinstance(self.recommended, Bool):
self.recommended = Bool(self.recommended)
if self.multivalued is not None and not isinstance(self.multivalued, Bool):
self.multivalued = Bool(self.multivalued)
if self.inlined is not None and not isinstance(self.inlined, Bool):
self.inlined = Bool(self.inlined)
if self.inlined_as_list is not None and not isinstance(self.inlined_as_list, Bool):
self.inlined_as_list = Bool(self.inlined_as_list)
if self.pattern is not None and not isinstance(self.pattern, str):
self.pattern = str(self.pattern)
if self.structured_pattern is not None and not isinstance(self.structured_pattern, PatternExpression):
self.structured_pattern = PatternExpression(**as_dict(self.structured_pattern))
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if self.implicit_prefix is not None and not isinstance(self.implicit_prefix, str):
self.implicit_prefix = str(self.implicit_prefix)
if self.value_presence is not None and not isinstance(self.value_presence, PresenceEnum):
self.value_presence = PresenceEnum(self.value_presence)
if self.equals_string is not None and not isinstance(self.equals_string, str):
self.equals_string = str(self.equals_string)
if not isinstance(self.equals_string_in, list):
self.equals_string_in = [self.equals_string_in] if self.equals_string_in is not None else []
self.equals_string_in = [v if isinstance(v, str) else str(v) for v in self.equals_string_in]
if self.equals_number is not None and not isinstance(self.equals_number, int):
self.equals_number = int(self.equals_number)
if self.equals_expression is not None and not isinstance(self.equals_expression, str):
self.equals_expression = str(self.equals_expression)
if self.exact_cardinality is not None and not isinstance(self.exact_cardinality, int):
self.exact_cardinality = int(self.exact_cardinality)
if self.minimum_cardinality is not None and not isinstance(self.minimum_cardinality, int):
self.minimum_cardinality = int(self.minimum_cardinality)
if self.maximum_cardinality is not None and not isinstance(self.maximum_cardinality, int):
self.maximum_cardinality = int(self.maximum_cardinality)
if self.has_member is not None and not isinstance(self.has_member, AnonymousSlotExpression):
self.has_member = AnonymousSlotExpression(**as_dict(self.has_member))
if self.all_members is not None and not isinstance(self.all_members, AnonymousSlotExpression):
self.all_members = AnonymousSlotExpression(**as_dict(self.all_members))
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.none_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.any_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.all_of
]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class AnonymousSlotExpression(AnonymousExpression):
_inherited_slots: ClassVar[list[str]] = [
"range",
"required",
"recommended",
"multivalued",
"inlined",
"inlined_as_list",
"minimum_value",
"maximum_value",
"pattern",
"structured_pattern",
"value_presence",
"equals_string",
"equals_string_in",
"equals_number",
"equals_expression",
"exact_cardinality",
"minimum_cardinality",
"maximum_cardinality",
]
class_class_uri: ClassVar[URIRef] = LINKML["AnonymousSlotExpression"]
class_class_curie: ClassVar[str] = "linkml:AnonymousSlotExpression"
class_name: ClassVar[str] = "anonymous_slot_expression"
class_model_uri: ClassVar[URIRef] = LINKML.AnonymousSlotExpression
range: Optional[Union[str, ElementName]] = None
range_expression: Optional[Union[dict, "AnonymousClassExpression"]] = None
enum_range: Optional[Union[dict, EnumExpression]] = None
bindings: Optional[Union[Union[dict, EnumBinding], list[Union[dict, EnumBinding]]]] = empty_list()
required: Optional[Union[bool, Bool]] = None
recommended: Optional[Union[bool, Bool]] = None
multivalued: Optional[Union[bool, Bool]] = None
inlined: Optional[Union[bool, Bool]] = None
inlined_as_list: Optional[Union[bool, Bool]] = None
minimum_value: Optional[Union[dict, Anything]] = None
maximum_value: Optional[Union[dict, Anything]] = None
pattern: Optional[str] = None
structured_pattern: Optional[Union[dict, "PatternExpression"]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
implicit_prefix: Optional[str] = None
value_presence: Optional[Union[str, "PresenceEnum"]] = None
equals_string: Optional[str] = None
equals_string_in: Optional[Union[str, list[str]]] = empty_list()
equals_number: Optional[int] = None
equals_expression: Optional[str] = None
exact_cardinality: Optional[int] = None
minimum_cardinality: Optional[int] = None
maximum_cardinality: Optional[int] = None
has_member: Optional[Union[dict, "AnonymousSlotExpression"]] = None
all_members: Optional[Union[dict, "AnonymousSlotExpression"]] = None
none_of: Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]
] = empty_list()
any_of: Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]] = (
empty_list()
)
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.range is not None and not isinstance(self.range, ElementName):
self.range = ElementName(self.range)
if self.range_expression is not None and not isinstance(self.range_expression, AnonymousClassExpression):
self.range_expression = AnonymousClassExpression(**as_dict(self.range_expression))
if self.enum_range is not None and not isinstance(self.enum_range, EnumExpression):
self.enum_range = EnumExpression(**as_dict(self.enum_range))
if not isinstance(self.bindings, list):
self.bindings = [self.bindings] if self.bindings is not None else []
self.bindings = [v if isinstance(v, EnumBinding) else EnumBinding(**as_dict(v)) for v in self.bindings]
if self.required is not None and not isinstance(self.required, Bool):
self.required = Bool(self.required)
if self.recommended is not None and not isinstance(self.recommended, Bool):
self.recommended = Bool(self.recommended)
if self.multivalued is not None and not isinstance(self.multivalued, Bool):
self.multivalued = Bool(self.multivalued)
if self.inlined is not None and not isinstance(self.inlined, Bool):
self.inlined = Bool(self.inlined)
if self.inlined_as_list is not None and not isinstance(self.inlined_as_list, Bool):
self.inlined_as_list = Bool(self.inlined_as_list)
if self.pattern is not None and not isinstance(self.pattern, str):
self.pattern = str(self.pattern)
if self.structured_pattern is not None and not isinstance(self.structured_pattern, PatternExpression):
self.structured_pattern = PatternExpression(**as_dict(self.structured_pattern))
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if self.implicit_prefix is not None and not isinstance(self.implicit_prefix, str):
self.implicit_prefix = str(self.implicit_prefix)
if self.value_presence is not None and not isinstance(self.value_presence, PresenceEnum):
self.value_presence = PresenceEnum(self.value_presence)
if self.equals_string is not None and not isinstance(self.equals_string, str):
self.equals_string = str(self.equals_string)
if not isinstance(self.equals_string_in, list):
self.equals_string_in = [self.equals_string_in] if self.equals_string_in is not None else []
self.equals_string_in = [v if isinstance(v, str) else str(v) for v in self.equals_string_in]
if self.equals_number is not None and not isinstance(self.equals_number, int):
self.equals_number = int(self.equals_number)
if self.equals_expression is not None and not isinstance(self.equals_expression, str):
self.equals_expression = str(self.equals_expression)
if self.exact_cardinality is not None and not isinstance(self.exact_cardinality, int):
self.exact_cardinality = int(self.exact_cardinality)
if self.minimum_cardinality is not None and not isinstance(self.minimum_cardinality, int):
self.minimum_cardinality = int(self.minimum_cardinality)
if self.maximum_cardinality is not None and not isinstance(self.maximum_cardinality, int):
self.maximum_cardinality = int(self.maximum_cardinality)
if self.has_member is not None and not isinstance(self.has_member, AnonymousSlotExpression):
self.has_member = AnonymousSlotExpression(**as_dict(self.has_member))
if self.all_members is not None and not isinstance(self.all_members, AnonymousSlotExpression):
self.all_members = AnonymousSlotExpression(**as_dict(self.all_members))
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.none_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.any_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.all_of
]
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class SlotDefinition(Definition):
"""
an element that describes how instances are related to other instances
"""
_inherited_slots: ClassVar[list[str]] = [
"domain",
"array",
"inherited",
"readonly",
"ifabsent",
"list_elements_unique",
"list_elements_ordered",
"shared",
"key",
"identifier",
"designates_type",
"role",
"relational_role",
"range",
"required",
"recommended",
"multivalued",
"inlined",
"inlined_as_list",
"minimum_value",
"maximum_value",
"pattern",
"structured_pattern",
"value_presence",
"equals_string",
"equals_string_in",
"equals_number",
"equals_expression",
"exact_cardinality",
"minimum_cardinality",
"maximum_cardinality",
]
class_class_uri: ClassVar[URIRef] = LINKML["SlotDefinition"]
class_class_curie: ClassVar[str] = "linkml:SlotDefinition"
class_name: ClassVar[str] = "slot_definition"
class_model_uri: ClassVar[URIRef] = LINKML.SlotDefinition
name: Union[str, SlotDefinitionName] = None
singular_name: Optional[str] = None
domain: Optional[Union[str, ClassDefinitionName]] = None
slot_uri: Optional[Union[str, URIorCURIE]] = None
array: Optional[Union[dict, "ArrayExpression"]] = None
inherited: Optional[Union[bool, Bool]] = None
readonly: Optional[str] = None
ifabsent: Optional[str] = None
list_elements_unique: Optional[Union[bool, Bool]] = None
list_elements_ordered: Optional[Union[bool, Bool]] = None
shared: Optional[Union[bool, Bool]] = None
key: Optional[Union[bool, Bool]] = None
identifier: Optional[Union[bool, Bool]] = None
designates_type: Optional[Union[bool, Bool]] = None
alias: Optional[str] = None
owner: Optional[Union[str, DefinitionName]] = None
domain_of: Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]] = empty_list()
subproperty_of: Optional[Union[str, SlotDefinitionName]] = None
symmetric: Optional[Union[bool, Bool]] = None
reflexive: Optional[Union[bool, Bool]] = None
locally_reflexive: Optional[Union[bool, Bool]] = None
irreflexive: Optional[Union[bool, Bool]] = None
asymmetric: Optional[Union[bool, Bool]] = None
transitive: Optional[Union[bool, Bool]] = None
inverse: Optional[Union[str, SlotDefinitionName]] = None
is_class_field: Optional[Union[bool, Bool]] = None
transitive_form_of: Optional[Union[str, SlotDefinitionName]] = None
reflexive_transitive_form_of: Optional[Union[str, SlotDefinitionName]] = None
role: Optional[str] = None
is_usage_slot: Optional[Union[bool, Bool]] = None
usage_slot_name: Optional[str] = None
relational_role: Optional[Union[str, "RelationalRoleEnum"]] = None
slot_group: Optional[Union[str, SlotDefinitionName]] = None
is_grouping_slot: Optional[Union[bool, Bool]] = None
path_rule: Optional[Union[dict, PathExpression]] = None
disjoint_with: Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]] = empty_list()
children_are_mutually_disjoint: Optional[Union[bool, Bool]] = None
union_of: Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]] = empty_list()
type_mappings: Optional[Union[Union[str, TypeMappingFramework], list[Union[str, TypeMappingFramework]]]] = (
empty_list()
)
is_a: Optional[Union[str, SlotDefinitionName]] = None
mixins: Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]] = empty_list()
apply_to: Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]] = empty_list()
range: Optional[Union[str, ElementName]] = None
range_expression: Optional[Union[dict, "AnonymousClassExpression"]] = None
enum_range: Optional[Union[dict, EnumExpression]] = None
bindings: Optional[Union[Union[dict, EnumBinding], list[Union[dict, EnumBinding]]]] = empty_list()
required: Optional[Union[bool, Bool]] = None
recommended: Optional[Union[bool, Bool]] = None
multivalued: Optional[Union[bool, Bool]] = None
inlined: Optional[Union[bool, Bool]] = None
inlined_as_list: Optional[Union[bool, Bool]] = None
minimum_value: Optional[Union[dict, Anything]] = None
maximum_value: Optional[Union[dict, Anything]] = None
pattern: Optional[str] = None
structured_pattern: Optional[Union[dict, "PatternExpression"]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
implicit_prefix: Optional[str] = None
value_presence: Optional[Union[str, "PresenceEnum"]] = None
equals_string: Optional[str] = None
equals_string_in: Optional[Union[str, list[str]]] = empty_list()
equals_number: Optional[int] = None
equals_expression: Optional[str] = None
exact_cardinality: Optional[int] = None
minimum_cardinality: Optional[int] = None
maximum_cardinality: Optional[int] = None
has_member: Optional[Union[dict, AnonymousSlotExpression]] = None
all_members: Optional[Union[dict, AnonymousSlotExpression]] = None
none_of: Optional[Union[Union[dict, AnonymousSlotExpression], list[Union[dict, AnonymousSlotExpression]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, AnonymousSlotExpression], list[Union[dict, AnonymousSlotExpression]]]
] = empty_list()
any_of: Optional[Union[Union[dict, AnonymousSlotExpression], list[Union[dict, AnonymousSlotExpression]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, AnonymousSlotExpression], list[Union[dict, AnonymousSlotExpression]]]] = (
empty_list()
)
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, SlotDefinitionName):
self.name = SlotDefinitionName(self.name)
if self.singular_name is not None and not isinstance(self.singular_name, str):
self.singular_name = str(self.singular_name)
if self.domain is not None and not isinstance(self.domain, ClassDefinitionName):
self.domain = ClassDefinitionName(self.domain)
if self.slot_uri is not None and not isinstance(self.slot_uri, URIorCURIE):
self.slot_uri = URIorCURIE(self.slot_uri)
if self.array is not None and not isinstance(self.array, ArrayExpression):
self.array = ArrayExpression(**as_dict(self.array))
if self.inherited is not None and not isinstance(self.inherited, Bool):
self.inherited = Bool(self.inherited)
if self.readonly is not None and not isinstance(self.readonly, str):
self.readonly = str(self.readonly)
if self.ifabsent is not None and not isinstance(self.ifabsent, str):
self.ifabsent = str(self.ifabsent)
if self.list_elements_unique is not None and not isinstance(self.list_elements_unique, Bool):
self.list_elements_unique = Bool(self.list_elements_unique)
if self.list_elements_ordered is not None and not isinstance(self.list_elements_ordered, Bool):
self.list_elements_ordered = Bool(self.list_elements_ordered)
if self.shared is not None and not isinstance(self.shared, Bool):
self.shared = Bool(self.shared)
if self.key is not None and not isinstance(self.key, Bool):
self.key = Bool(self.key)
if self.identifier is not None and not isinstance(self.identifier, Bool):
self.identifier = Bool(self.identifier)
if self.designates_type is not None and not isinstance(self.designates_type, Bool):
self.designates_type = Bool(self.designates_type)
if self.alias is not None and not isinstance(self.alias, str):
self.alias = str(self.alias)
if self.owner is not None and not isinstance(self.owner, DefinitionName):
self.owner = DefinitionName(self.owner)
if not isinstance(self.domain_of, list):
self.domain_of = [self.domain_of] if self.domain_of is not None else []
self.domain_of = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in self.domain_of]
if self.subproperty_of is not None and not isinstance(self.subproperty_of, SlotDefinitionName):
self.subproperty_of = SlotDefinitionName(self.subproperty_of)
if self.symmetric is not None and not isinstance(self.symmetric, Bool):
self.symmetric = Bool(self.symmetric)
if self.reflexive is not None and not isinstance(self.reflexive, Bool):
self.reflexive = Bool(self.reflexive)
if self.locally_reflexive is not None and not isinstance(self.locally_reflexive, Bool):
self.locally_reflexive = Bool(self.locally_reflexive)
if self.irreflexive is not None and not isinstance(self.irreflexive, Bool):
self.irreflexive = Bool(self.irreflexive)
if self.asymmetric is not None and not isinstance(self.asymmetric, Bool):
self.asymmetric = Bool(self.asymmetric)
if self.transitive is not None and not isinstance(self.transitive, Bool):
self.transitive = Bool(self.transitive)
if self.inverse is not None and not isinstance(self.inverse, SlotDefinitionName):
self.inverse = SlotDefinitionName(self.inverse)
if self.is_class_field is not None and not isinstance(self.is_class_field, Bool):
self.is_class_field = Bool(self.is_class_field)
if self.transitive_form_of is not None and not isinstance(self.transitive_form_of, SlotDefinitionName):
self.transitive_form_of = SlotDefinitionName(self.transitive_form_of)
if self.reflexive_transitive_form_of is not None and not isinstance(
self.reflexive_transitive_form_of, SlotDefinitionName
):
self.reflexive_transitive_form_of = SlotDefinitionName(self.reflexive_transitive_form_of)
if self.role is not None and not isinstance(self.role, str):
self.role = str(self.role)
if self.is_usage_slot is not None and not isinstance(self.is_usage_slot, Bool):
self.is_usage_slot = Bool(self.is_usage_slot)
if self.usage_slot_name is not None and not isinstance(self.usage_slot_name, str):
self.usage_slot_name = str(self.usage_slot_name)
if self.relational_role is not None and not isinstance(self.relational_role, RelationalRoleEnum):
self.relational_role = RelationalRoleEnum(self.relational_role)
if self.slot_group is not None and not isinstance(self.slot_group, SlotDefinitionName):
self.slot_group = SlotDefinitionName(self.slot_group)
if self.is_grouping_slot is not None and not isinstance(self.is_grouping_slot, Bool):
self.is_grouping_slot = Bool(self.is_grouping_slot)
if self.path_rule is not None and not isinstance(self.path_rule, PathExpression):
self.path_rule = PathExpression(**as_dict(self.path_rule))
if not isinstance(self.disjoint_with, list):
self.disjoint_with = [self.disjoint_with] if self.disjoint_with is not None else []
self.disjoint_with = [
v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.disjoint_with
]
if self.children_are_mutually_disjoint is not None and not isinstance(
self.children_are_mutually_disjoint, Bool
):
self.children_are_mutually_disjoint = Bool(self.children_are_mutually_disjoint)
if not isinstance(self.union_of, list):
self.union_of = [self.union_of] if self.union_of is not None else []
self.union_of = [v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.union_of]
if not isinstance(self.type_mappings, list):
self.type_mappings = [self.type_mappings] if self.type_mappings is not None else []
self.type_mappings = [
v if isinstance(v, TypeMappingFramework) else TypeMappingFramework(v) for v in self.type_mappings
]
if self.is_a is not None and not isinstance(self.is_a, SlotDefinitionName):
self.is_a = SlotDefinitionName(self.is_a)
if not isinstance(self.mixins, list):
self.mixins = [self.mixins] if self.mixins is not None else []
self.mixins = [v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.mixins]
if not isinstance(self.apply_to, list):
self.apply_to = [self.apply_to] if self.apply_to is not None else []
self.apply_to = [v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.apply_to]
if self.range is not None and not isinstance(self.range, ElementName):
self.range = ElementName(self.range)
if self.range_expression is not None and not isinstance(self.range_expression, AnonymousClassExpression):
self.range_expression = AnonymousClassExpression(**as_dict(self.range_expression))
if self.enum_range is not None and not isinstance(self.enum_range, EnumExpression):
self.enum_range = EnumExpression(**as_dict(self.enum_range))
if not isinstance(self.bindings, list):
self.bindings = [self.bindings] if self.bindings is not None else []
self.bindings = [v if isinstance(v, EnumBinding) else EnumBinding(**as_dict(v)) for v in self.bindings]
if self.required is not None and not isinstance(self.required, Bool):
self.required = Bool(self.required)
if self.recommended is not None and not isinstance(self.recommended, Bool):
self.recommended = Bool(self.recommended)
if self.multivalued is not None and not isinstance(self.multivalued, Bool):
self.multivalued = Bool(self.multivalued)
if self.inlined is not None and not isinstance(self.inlined, Bool):
self.inlined = Bool(self.inlined)
if self.inlined_as_list is not None and not isinstance(self.inlined_as_list, Bool):
self.inlined_as_list = Bool(self.inlined_as_list)
if self.pattern is not None and not isinstance(self.pattern, str):
self.pattern = str(self.pattern)
if self.structured_pattern is not None and not isinstance(self.structured_pattern, PatternExpression):
self.structured_pattern = PatternExpression(**as_dict(self.structured_pattern))
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if self.implicit_prefix is not None and not isinstance(self.implicit_prefix, str):
self.implicit_prefix = str(self.implicit_prefix)
if self.value_presence is not None and not isinstance(self.value_presence, PresenceEnum):
self.value_presence = PresenceEnum(self.value_presence)
if self.equals_string is not None and not isinstance(self.equals_string, str):
self.equals_string = str(self.equals_string)
if not isinstance(self.equals_string_in, list):
self.equals_string_in = [self.equals_string_in] if self.equals_string_in is not None else []
self.equals_string_in = [v if isinstance(v, str) else str(v) for v in self.equals_string_in]
if self.equals_number is not None and not isinstance(self.equals_number, int):
self.equals_number = int(self.equals_number)
if self.equals_expression is not None and not isinstance(self.equals_expression, str):
self.equals_expression = str(self.equals_expression)
if self.exact_cardinality is not None and not isinstance(self.exact_cardinality, int):
self.exact_cardinality = int(self.exact_cardinality)
if self.minimum_cardinality is not None and not isinstance(self.minimum_cardinality, int):
self.minimum_cardinality = int(self.minimum_cardinality)
if self.maximum_cardinality is not None and not isinstance(self.maximum_cardinality, int):
self.maximum_cardinality = int(self.maximum_cardinality)
if self.has_member is not None and not isinstance(self.has_member, AnonymousSlotExpression):
self.has_member = AnonymousSlotExpression(**as_dict(self.has_member))
if self.all_members is not None and not isinstance(self.all_members, AnonymousSlotExpression):
self.all_members = AnonymousSlotExpression(**as_dict(self.all_members))
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.none_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.any_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousSlotExpression) else AnonymousSlotExpression(**as_dict(v)) for v in self.all_of
]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class ClassExpression(YAMLRoot):
"""
A boolean expression that can be used to dynamically determine membership of a class
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["ClassExpression"]
class_class_curie: ClassVar[str] = "linkml:ClassExpression"
class_name: ClassVar[str] = "class_expression"
class_model_uri: ClassVar[URIRef] = LINKML.ClassExpression
any_of: Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]
] = empty_list()
none_of: Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]] = (
empty_list()
)
slot_conditions: Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
] = empty_dict()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.any_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.none_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.all_of
]
self._normalize_inlined_as_dict(
slot_name="slot_conditions", slot_type=SlotDefinition, key_name="name", keyed=True
)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class AnonymousClassExpression(AnonymousExpression):
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["AnonymousClassExpression"]
class_class_curie: ClassVar[str] = "linkml:AnonymousClassExpression"
class_name: ClassVar[str] = "anonymous_class_expression"
class_model_uri: ClassVar[URIRef] = LINKML.AnonymousClassExpression
is_a: Optional[Union[str, DefinitionName]] = None
any_of: Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]
] = empty_list()
none_of: Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]] = (
empty_list()
)
slot_conditions: Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
] = empty_dict()
def __post_init__(self, *_: list[str], **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)
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.any_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.none_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.all_of
]
self._normalize_inlined_as_dict(
slot_name="slot_conditions", slot_type=SlotDefinition, key_name="name", keyed=True
)
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class ClassDefinition(Definition):
"""
an element whose instances are complex objects that may have slot-value assignments
"""
_inherited_slots: ClassVar[list[str]] = ["defining_slots", "represents_relationship"]
class_class_uri: ClassVar[URIRef] = LINKML["ClassDefinition"]
class_class_curie: ClassVar[str] = "linkml:ClassDefinition"
class_name: ClassVar[str] = "class_definition"
class_model_uri: ClassVar[URIRef] = LINKML.ClassDefinition
name: Union[str, ClassDefinitionName] = None
slots: Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]] = empty_list()
slot_usage: Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
] = empty_dict()
attributes: Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
] = empty_dict()
class_uri: Optional[Union[str, URIorCURIE]] = None
subclass_of: Optional[Union[str, URIorCURIE]] = None
union_of: Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]] = empty_list()
defining_slots: Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]] = empty_list()
tree_root: Optional[Union[bool, Bool]] = None
unique_keys: Optional[
Union[dict[Union[str, UniqueKeyUniqueKeyName], Union[dict, "UniqueKey"]], list[Union[dict, "UniqueKey"]]]
] = empty_dict()
rules: Optional[Union[Union[dict, "ClassRule"], list[Union[dict, "ClassRule"]]]] = empty_list()
classification_rules: Optional[
Union[Union[dict, AnonymousClassExpression], list[Union[dict, AnonymousClassExpression]]]
] = empty_list()
slot_names_unique: Optional[Union[bool, Bool]] = None
represents_relationship: Optional[Union[bool, Bool]] = None
disjoint_with: Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]] = (
empty_list()
)
children_are_mutually_disjoint: Optional[Union[bool, Bool]] = None
is_a: Optional[Union[str, ClassDefinitionName]] = None
mixins: Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]] = empty_list()
apply_to: Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]] = empty_list()
any_of: Optional[Union[Union[dict, AnonymousClassExpression], list[Union[dict, AnonymousClassExpression]]]] = (
empty_list()
)
exactly_one_of: Optional[
Union[Union[dict, AnonymousClassExpression], list[Union[dict, AnonymousClassExpression]]]
] = empty_list()
none_of: Optional[Union[Union[dict, AnonymousClassExpression], list[Union[dict, AnonymousClassExpression]]]] = (
empty_list()
)
all_of: Optional[Union[Union[dict, AnonymousClassExpression], list[Union[dict, AnonymousClassExpression]]]] = (
empty_list()
)
slot_conditions: Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
] = empty_dict()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, ClassDefinitionName):
self.name = ClassDefinitionName(self.name)
if not isinstance(self.slots, list):
self.slots = [self.slots] if self.slots is not None else []
self.slots = [v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.slots]
self._normalize_inlined_as_dict(slot_name="slot_usage", slot_type=SlotDefinition, key_name="name", keyed=True)
self._normalize_inlined_as_dict(slot_name="attributes", slot_type=SlotDefinition, key_name="name", keyed=True)
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)
if not isinstance(self.union_of, list):
self.union_of = [self.union_of] if self.union_of is not None else []
self.union_of = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in self.union_of]
if not isinstance(self.defining_slots, list):
self.defining_slots = [self.defining_slots] if self.defining_slots is not None else []
self.defining_slots = [
v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.defining_slots
]
if self.tree_root is not None and not isinstance(self.tree_root, Bool):
self.tree_root = Bool(self.tree_root)
self._normalize_inlined_as_dict(
slot_name="unique_keys", slot_type=UniqueKey, key_name="unique_key_name", keyed=True
)
if not isinstance(self.rules, list):
self.rules = [self.rules] if self.rules is not None else []
self.rules = [v if isinstance(v, ClassRule) else ClassRule(**as_dict(v)) for v in self.rules]
if not isinstance(self.classification_rules, list):
self.classification_rules = [self.classification_rules] if self.classification_rules is not None else []
self.classification_rules = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.classification_rules
]
if self.slot_names_unique is not None and not isinstance(self.slot_names_unique, Bool):
self.slot_names_unique = Bool(self.slot_names_unique)
if self.represents_relationship is not None and not isinstance(self.represents_relationship, Bool):
self.represents_relationship = Bool(self.represents_relationship)
if not isinstance(self.disjoint_with, list):
self.disjoint_with = [self.disjoint_with] if self.disjoint_with is not None else []
self.disjoint_with = [
v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in self.disjoint_with
]
if self.children_are_mutually_disjoint is not None and not isinstance(
self.children_are_mutually_disjoint, Bool
):
self.children_are_mutually_disjoint = Bool(self.children_are_mutually_disjoint)
if self.is_a is not None and not isinstance(self.is_a, ClassDefinitionName):
self.is_a = ClassDefinitionName(self.is_a)
if not isinstance(self.mixins, list):
self.mixins = [self.mixins] if self.mixins is not None else []
self.mixins = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in self.mixins]
if not isinstance(self.apply_to, list):
self.apply_to = [self.apply_to] if self.apply_to is not None else []
self.apply_to = [v if isinstance(v, ClassDefinitionName) else ClassDefinitionName(v) for v in self.apply_to]
if not isinstance(self.any_of, list):
self.any_of = [self.any_of] if self.any_of is not None else []
self.any_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.any_of
]
if not isinstance(self.exactly_one_of, list):
self.exactly_one_of = [self.exactly_one_of] if self.exactly_one_of is not None else []
self.exactly_one_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.exactly_one_of
]
if not isinstance(self.none_of, list):
self.none_of = [self.none_of] if self.none_of is not None else []
self.none_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.none_of
]
if not isinstance(self.all_of, list):
self.all_of = [self.all_of] if self.all_of is not None else []
self.all_of = [
v if isinstance(v, AnonymousClassExpression) else AnonymousClassExpression(**as_dict(v))
for v in self.all_of
]
self._normalize_inlined_as_dict(
slot_name="slot_conditions", slot_type=SlotDefinition, key_name="name", keyed=True
)
super().__post_init__(**kwargs)
class ClassLevelRule(YAMLRoot):
"""
A rule that is applied to classes
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["ClassLevelRule"]
class_class_curie: ClassVar[str] = "linkml:ClassLevelRule"
class_name: ClassVar[str] = "class_level_rule"
class_model_uri: ClassVar[URIRef] = LINKML.ClassLevelRule
@dataclass(repr=False)
class ClassRule(ClassLevelRule):
"""
A rule that applies to instances of a class
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["ClassRule"]
class_class_curie: ClassVar[str] = "linkml:ClassRule"
class_name: ClassVar[str] = "class_rule"
class_model_uri: ClassVar[URIRef] = LINKML.ClassRule
preconditions: Optional[Union[dict, AnonymousClassExpression]] = None
postconditions: Optional[Union[dict, AnonymousClassExpression]] = None
elseconditions: Optional[Union[dict, AnonymousClassExpression]] = None
bidirectional: Optional[Union[bool, Bool]] = None
open_world: Optional[Union[bool, Bool]] = None
rank: Optional[int] = None
deactivated: Optional[Union[bool, Bool]] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.preconditions is not None and not isinstance(self.preconditions, AnonymousClassExpression):
self.preconditions = AnonymousClassExpression(**as_dict(self.preconditions))
if self.postconditions is not None and not isinstance(self.postconditions, AnonymousClassExpression):
self.postconditions = AnonymousClassExpression(**as_dict(self.postconditions))
if self.elseconditions is not None and not isinstance(self.elseconditions, AnonymousClassExpression):
self.elseconditions = AnonymousClassExpression(**as_dict(self.elseconditions))
if self.bidirectional is not None and not isinstance(self.bidirectional, Bool):
self.bidirectional = Bool(self.bidirectional)
if self.open_world is not None and not isinstance(self.open_world, Bool):
self.open_world = Bool(self.open_world)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if self.deactivated is not None and not isinstance(self.deactivated, Bool):
self.deactivated = Bool(self.deactivated)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class ArrayExpression(YAMLRoot):
"""
defines the dimensions of an array
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["ArrayExpression"]
class_class_curie: ClassVar[str] = "linkml:ArrayExpression"
class_name: ClassVar[str] = "array_expression"
class_model_uri: ClassVar[URIRef] = LINKML.ArrayExpression
exact_number_dimensions: Optional[int] = None
minimum_number_dimensions: Optional[int] = None
maximum_number_dimensions: Optional[Union[dict, Anything]] = None
dimensions: Optional[Union[Union[dict, "DimensionExpression"], list[Union[dict, "DimensionExpression"]]]] = (
empty_list()
)
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.exact_number_dimensions is not None and not isinstance(self.exact_number_dimensions, int):
self.exact_number_dimensions = int(self.exact_number_dimensions)
if self.minimum_number_dimensions is not None and not isinstance(self.minimum_number_dimensions, int):
self.minimum_number_dimensions = int(self.minimum_number_dimensions)
if not isinstance(self.dimensions, list):
self.dimensions = [self.dimensions] if self.dimensions is not None else []
self.dimensions = [
v if isinstance(v, DimensionExpression) else DimensionExpression(**as_dict(v)) for v in self.dimensions
]
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
[docs]
@dataclass(repr=False)
class DimensionExpression(YAMLRoot):
"""
defines one of the dimensions of an array
"""
_inherited_slots: ClassVar[list[str]] = ["maximum_cardinality", "minimum_cardinality", "exact_cardinality"]
class_class_uri: ClassVar[URIRef] = LINKML["DimensionExpression"]
class_class_curie: ClassVar[str] = "linkml:DimensionExpression"
class_name: ClassVar[str] = "dimension_expression"
class_model_uri: ClassVar[URIRef] = LINKML.DimensionExpression
alias: Optional[str] = None
maximum_cardinality: Optional[int] = None
minimum_cardinality: Optional[int] = None
exact_cardinality: Optional[int] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.alias is not None and not isinstance(self.alias, str):
self.alias = str(self.alias)
if self.maximum_cardinality is not None and not isinstance(self.maximum_cardinality, int):
self.maximum_cardinality = int(self.maximum_cardinality)
if self.minimum_cardinality is not None and not isinstance(self.minimum_cardinality, int):
self.minimum_cardinality = int(self.minimum_cardinality)
if self.exact_cardinality is not None and not isinstance(self.exact_cardinality, int):
self.exact_cardinality = int(self.exact_cardinality)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class PatternExpression(YAMLRoot):
"""
a regular expression pattern used to evaluate conformance of a string
"""
_inherited_slots: ClassVar[list[str]] = ["syntax"]
class_class_uri: ClassVar[URIRef] = LINKML["PatternExpression"]
class_class_curie: ClassVar[str] = "linkml:PatternExpression"
class_name: ClassVar[str] = "pattern_expression"
class_model_uri: ClassVar[URIRef] = LINKML.PatternExpression
syntax: Optional[str] = None
interpolated: Optional[Union[bool, Bool]] = None
partial_match: Optional[Union[bool, Bool]] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.syntax is not None and not isinstance(self.syntax, str):
self.syntax = str(self.syntax)
if self.interpolated is not None and not isinstance(self.interpolated, Bool):
self.interpolated = Bool(self.interpolated)
if self.partial_match is not None and not isinstance(self.partial_match, Bool):
self.partial_match = Bool(self.partial_match)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class ImportExpression(YAMLRoot):
"""
an expression describing an import
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["ImportExpression"]
class_class_curie: ClassVar[str] = "linkml:ImportExpression"
class_name: ClassVar[str] = "import_expression"
class_model_uri: ClassVar[URIRef] = LINKML.ImportExpression
import_from: Union[str, URIorCURIE] = None
import_as: Optional[Union[str, NCName]] = None
import_map: Optional[
Union[dict[Union[str, SettingSettingKey], Union[dict, "Setting"]], list[Union[dict, "Setting"]]]
] = empty_dict()
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.import_from):
self.MissingRequiredField("import_from")
if not isinstance(self.import_from, URIorCURIE):
self.import_from = URIorCURIE(self.import_from)
if self.import_as is not None and not isinstance(self.import_as, NCName):
self.import_as = NCName(self.import_as)
self._normalize_inlined_as_dict(slot_name="import_map", slot_type=Setting, key_name="setting_key", keyed=True)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Setting(YAMLRoot):
"""
assignment of a key to a value
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["Setting"]
class_class_curie: ClassVar[str] = "linkml:Setting"
class_name: ClassVar[str] = "setting"
class_model_uri: ClassVar[URIRef] = LINKML.Setting
setting_key: Union[str, SettingSettingKey] = None
setting_value: str = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.setting_key):
self.MissingRequiredField("setting_key")
if not isinstance(self.setting_key, SettingSettingKey):
self.setting_key = SettingSettingKey(self.setting_key)
if self._is_empty(self.setting_value):
self.MissingRequiredField("setting_value")
if not isinstance(self.setting_value, str):
self.setting_value = str(self.setting_value)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Prefix(YAMLRoot):
"""
prefix URI tuple
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["Prefix"]
class_class_curie: ClassVar[str] = "linkml:Prefix"
class_name: ClassVar[str] = "prefix"
class_model_uri: ClassVar[URIRef] = LINKML.Prefix
prefix_prefix: Union[str, PrefixPrefixPrefix] = None
prefix_reference: Union[str, URI] = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.prefix_prefix):
self.MissingRequiredField("prefix_prefix")
if not isinstance(self.prefix_prefix, PrefixPrefixPrefix):
self.prefix_prefix = PrefixPrefixPrefix(self.prefix_prefix)
if self._is_empty(self.prefix_reference):
self.MissingRequiredField("prefix_reference")
if not isinstance(self.prefix_reference, URI):
self.prefix_reference = URI(self.prefix_reference)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class LocalName(YAMLRoot):
"""
an attributed label
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["LocalName"]
class_class_curie: ClassVar[str] = "linkml:LocalName"
class_name: ClassVar[str] = "local_name"
class_model_uri: ClassVar[URIRef] = LINKML.LocalName
local_name_source: Union[str, LocalNameLocalNameSource] = None
local_name_value: str = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.local_name_source):
self.MissingRequiredField("local_name_source")
if not isinstance(self.local_name_source, LocalNameLocalNameSource):
self.local_name_source = LocalNameLocalNameSource(self.local_name_source)
if self._is_empty(self.local_name_value):
self.MissingRequiredField("local_name_value")
if not isinstance(self.local_name_value, str):
self.local_name_value = str(self.local_name_value)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Example(YAMLRoot):
"""
usage example and description
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["Example"]
class_class_curie: ClassVar[str] = "linkml:Example"
class_name: ClassVar[str] = "example"
class_model_uri: ClassVar[URIRef] = LINKML.Example
value: Optional[str] = None
description: Optional[str] = None
object: Optional[Union[dict, Anything]] = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self.value is not None and not isinstance(self.value, str):
self.value = str(self.value)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class AltDescription(YAMLRoot):
"""
an attributed description
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["AltDescription"]
class_class_curie: ClassVar[str] = "linkml:AltDescription"
class_name: ClassVar[str] = "alt_description"
class_model_uri: ClassVar[URIRef] = LINKML.AltDescription
source: Union[str, AltDescriptionSource] = None
description: str = None
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.source):
self.MissingRequiredField("source")
if not isinstance(self.source, AltDescriptionSource):
self.source = AltDescriptionSource(self.source)
if self._is_empty(self.description):
self.MissingRequiredField("description")
if not isinstance(self.description, str):
self.description = str(self.description)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class PermissibleValue(YAMLRoot):
"""
a permissible value, accompanied by intended text and an optional mapping to a concept URI
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["PermissibleValue"]
class_class_curie: ClassVar[str] = "linkml:PermissibleValue"
class_name: ClassVar[str] = "permissible_value"
class_model_uri: ClassVar[URIRef] = LINKML.PermissibleValue
text: Union[str, PermissibleValueText] = None
description: Optional[str] = None
meaning: Optional[Union[str, URIorCURIE]] = None
unit: Optional[Union[dict, UnitOfMeasure]] = None
instantiates: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
implements: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
is_a: Optional[Union[str, PermissibleValueText]] = None
mixins: Optional[Union[Union[str, PermissibleValueText], list[Union[str, PermissibleValueText]]]] = empty_list()
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
alt_descriptions: Optional[
Union[dict[Union[str, AltDescriptionSource], Union[dict, AltDescription]], list[Union[dict, AltDescription]]]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, Example], list[Union[dict, Example]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.text):
self.MissingRequiredField("text")
if not isinstance(self.text, PermissibleValueText):
self.text = PermissibleValueText(self.text)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
if self.meaning is not None and not isinstance(self.meaning, URIorCURIE):
self.meaning = URIorCURIE(self.meaning)
if self.unit is not None and not isinstance(self.unit, UnitOfMeasure):
self.unit = UnitOfMeasure(**as_dict(self.unit))
if not isinstance(self.instantiates, list):
self.instantiates = [self.instantiates] if self.instantiates is not None else []
self.instantiates = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.instantiates]
if not isinstance(self.implements, list):
self.implements = [self.implements] if self.implements is not None else []
self.implements = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.implements]
if self.is_a is not None and not isinstance(self.is_a, PermissibleValueText):
self.is_a = PermissibleValueText(self.is_a)
if not isinstance(self.mixins, list):
self.mixins = [self.mixins] if self.mixins is not None else []
self.mixins = [v if isinstance(v, PermissibleValueText) else PermissibleValueText(v) for v in self.mixins]
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class UniqueKey(YAMLRoot):
"""
a collection of slots whose values uniquely identify an instance of a class
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["UniqueKey"]
class_class_curie: ClassVar[str] = "linkml:UniqueKey"
class_name: ClassVar[str] = "unique_key"
class_model_uri: ClassVar[URIRef] = LINKML.UniqueKey
unique_key_name: Union[str, UniqueKeyUniqueKeyName] = None
unique_key_slots: Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]] = None
consider_nulls_inequal: Optional[Union[bool, Bool]] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[dict[Union[str, AltDescriptionSource], Union[dict, AltDescription]], list[Union[dict, AltDescription]]]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, Example], list[Union[dict, Example]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.unique_key_name):
self.MissingRequiredField("unique_key_name")
if not isinstance(self.unique_key_name, UniqueKeyUniqueKeyName):
self.unique_key_name = UniqueKeyUniqueKeyName(self.unique_key_name)
if self._is_empty(self.unique_key_slots):
self.MissingRequiredField("unique_key_slots")
if not isinstance(self.unique_key_slots, list):
self.unique_key_slots = [self.unique_key_slots] if self.unique_key_slots is not None else []
self.unique_key_slots = [
v if isinstance(v, SlotDefinitionName) else SlotDefinitionName(v) for v in self.unique_key_slots
]
if self.consider_nulls_inequal is not None and not isinstance(self.consider_nulls_inequal, Bool):
self.consider_nulls_inequal = Bool(self.consider_nulls_inequal)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
@dataclass
class TypeMapping(YAMLRoot):
"""
Represents how a slot or type can be serialized to a format.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = LINKML["TypeMapping"]
class_class_curie: ClassVar[str] = "linkml:TypeMapping"
class_name: ClassVar[str] = "type_mapping"
class_model_uri: ClassVar[URIRef] = LINKML.TypeMapping
framework: Union[str, TypeMappingFramework] = None
type: Optional[Union[str, TypeDefinitionName]] = None
string_serialization: Optional[str] = None
extensions: Optional[
Union[dict[Union[str, ExtensionTag], Union[dict, Extension]], list[Union[dict, Extension]]]
] = empty_dict()
annotations: Optional[
Union[dict[Union[str, AnnotationTag], Union[dict, Annotation]], list[Union[dict, Annotation]]]
] = empty_dict()
description: Optional[str] = None
alt_descriptions: Optional[
Union[dict[Union[str, AltDescriptionSource], Union[dict, AltDescription]], list[Union[dict, AltDescription]]]
] = empty_dict()
title: Optional[str] = None
deprecated: Optional[str] = None
todos: Optional[Union[str, list[str]]] = empty_list()
notes: Optional[Union[str, list[str]]] = empty_list()
comments: Optional[Union[str, list[str]]] = empty_list()
examples: Optional[Union[Union[dict, Example], list[Union[dict, Example]]]] = empty_list()
in_subset: Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]] = empty_list()
from_schema: Optional[Union[str, URI]] = None
imported_from: Optional[str] = None
source: Optional[Union[str, URIorCURIE]] = None
in_language: Optional[str] = None
see_also: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
deprecated_element_has_exact_replacement: Optional[Union[str, URIorCURIE]] = None
deprecated_element_has_possible_replacement: Optional[Union[str, URIorCURIE]] = None
aliases: Optional[Union[str, list[str]]] = empty_list()
structured_aliases: Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]] = empty_list()
mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
exact_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
close_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
related_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
narrow_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
broad_mappings: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
created_by: Optional[Union[str, URIorCURIE]] = None
contributors: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
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
rank: Optional[int] = None
categories: Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]] = empty_list()
keywords: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: list[str], **kwargs: dict[str, Any]):
if self._is_empty(self.framework):
self.MissingRequiredField("framework")
if not isinstance(self.framework, TypeMappingFramework):
self.framework = TypeMappingFramework(self.framework)
if self.type is not None and not isinstance(self.type, TypeDefinitionName):
self.type = TypeDefinitionName(self.type)
if self.string_serialization is not None and not isinstance(self.string_serialization, str):
self.string_serialization = str(self.string_serialization)
self._normalize_inlined_as_dict(slot_name="extensions", slot_type=Extension, key_name="tag", keyed=True)
self._normalize_inlined_as_dict(slot_name="annotations", slot_type=Annotation, key_name="tag", keyed=True)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
self._normalize_inlined_as_dict(
slot_name="alt_descriptions", slot_type=AltDescription, key_name="source", keyed=True
)
if self.title is not None and not isinstance(self.title, str):
self.title = str(self.title)
if self.deprecated is not None and not isinstance(self.deprecated, str):
self.deprecated = str(self.deprecated)
if not isinstance(self.todos, list):
self.todos = [self.todos] if self.todos is not None else []
self.todos = [v if isinstance(v, str) else str(v) for v in self.todos]
if not isinstance(self.notes, list):
self.notes = [self.notes] if self.notes is not None else []
self.notes = [v if isinstance(v, str) else str(v) for v in self.notes]
if not isinstance(self.comments, list):
self.comments = [self.comments] if self.comments is not None else []
self.comments = [v if isinstance(v, str) else str(v) for v in self.comments]
if not isinstance(self.examples, list):
self.examples = [self.examples] if self.examples is not None else []
self.examples = [v if isinstance(v, Example) else Example(**as_dict(v)) for v in self.examples]
if not isinstance(self.in_subset, list):
self.in_subset = [self.in_subset] if self.in_subset is not None else []
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)
if self.imported_from is not None and not isinstance(self.imported_from, str):
self.imported_from = str(self.imported_from)
if self.source is not None and not isinstance(self.source, URIorCURIE):
self.source = URIorCURIE(self.source)
if self.in_language is not None and not isinstance(self.in_language, str):
self.in_language = str(self.in_language)
if not isinstance(self.see_also, list):
self.see_also = [self.see_also] if self.see_also is not None else []
self.see_also = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.see_also]
if self.deprecated_element_has_exact_replacement is not None and not isinstance(
self.deprecated_element_has_exact_replacement, URIorCURIE
):
self.deprecated_element_has_exact_replacement = URIorCURIE(self.deprecated_element_has_exact_replacement)
if self.deprecated_element_has_possible_replacement is not None and not isinstance(
self.deprecated_element_has_possible_replacement, URIorCURIE
):
self.deprecated_element_has_possible_replacement = URIorCURIE(
self.deprecated_element_has_possible_replacement
)
if not isinstance(self.aliases, list):
self.aliases = [self.aliases] if self.aliases is not None else []
self.aliases = [v if isinstance(v, str) else str(v) for v in self.aliases]
self._normalize_inlined_as_dict(
slot_name="structured_aliases", slot_type=StructuredAlias, key_name="literal_form", keyed=False
)
if not isinstance(self.mappings, list):
self.mappings = [self.mappings] if self.mappings is not None else []
self.mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.mappings]
if not isinstance(self.exact_mappings, list):
self.exact_mappings = [self.exact_mappings] if self.exact_mappings is not None else []
self.exact_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.exact_mappings]
if not isinstance(self.close_mappings, list):
self.close_mappings = [self.close_mappings] if self.close_mappings is not None else []
self.close_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.close_mappings]
if not isinstance(self.related_mappings, list):
self.related_mappings = [self.related_mappings] if self.related_mappings is not None else []
self.related_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.related_mappings]
if not isinstance(self.narrow_mappings, list):
self.narrow_mappings = [self.narrow_mappings] if self.narrow_mappings is not None else []
self.narrow_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.narrow_mappings]
if not isinstance(self.broad_mappings, list):
self.broad_mappings = [self.broad_mappings] if self.broad_mappings is not None else []
self.broad_mappings = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.broad_mappings]
if self.created_by is not None and not isinstance(self.created_by, URIorCURIE):
self.created_by = URIorCURIE(self.created_by)
if not isinstance(self.contributors, list):
self.contributors = [self.contributors] if self.contributors is not None else []
self.contributors = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.contributors]
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)
if self.rank is not None and not isinstance(self.rank, int):
self.rank = int(self.rank)
if not isinstance(self.categories, list):
self.categories = [self.categories] if self.categories is not None else []
self.categories = [v if isinstance(v, URIorCURIE) else URIorCURIE(v) for v in self.categories]
if not isinstance(self.keywords, list):
self.keywords = [self.keywords] if self.keywords is not None else []
self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords]
super().__post_init__(**kwargs)
# Enumerations
class PvFormulaOptions(EnumDefinitionImpl):
"""
The formula used to generate the set of permissible values from the code_set values
"""
CODE = PermissibleValue(
text="CODE", description="The permissible values are the set of possible codes in the code set"
)
CURIE = PermissibleValue(text="CURIE", description="The permissible values are the set of CURIES in the code set")
URI = PermissibleValue(text="URI", description="The permissible values are the set of code URIs in the code set")
FHIR_CODING = PermissibleValue(
text="FHIR_CODING",
description="The permissible values are the set of FHIR coding elements derived from the code set",
)
LABEL = PermissibleValue(
text="LABEL", description="The permissible values are the set of human readable labels in the code set"
)
_defn = EnumDefinition(
name="PvFormulaOptions",
description="The formula used to generate the set of permissible values from the code_set values",
)
class PresenceEnum(EnumDefinitionImpl):
"""
enumeration of conditions by which a slot value should be set
"""
UNCOMMITTED = PermissibleValue(text="UNCOMMITTED")
PRESENT = PermissibleValue(text="PRESENT")
ABSENT = PermissibleValue(text="ABSENT")
_defn = EnumDefinition(
name="PresenceEnum",
description="enumeration of conditions by which a slot value should be set",
)
class RelationalRoleEnum(EnumDefinitionImpl):
"""
enumeration of roles a slot on a relationship class can play
"""
SUBJECT = PermissibleValue(
text="SUBJECT",
description="a slot with this role connects a relationship to its subject/source node",
meaning=RDF["subject"],
)
OBJECT = PermissibleValue(
text="OBJECT",
description="a slot with this role connects a relationship to its object/target node",
meaning=RDF["object"],
)
PREDICATE = PermissibleValue(
text="PREDICATE",
description="a slot with this role connects a relationship to its predicate/property",
meaning=RDF["predicate"],
)
NODE = PermissibleValue(
text="NODE",
description="""a slot with this role connects a symmetric relationship to a node that represents either subject or object node""",
)
OTHER_ROLE = PermissibleValue(
text="OTHER_ROLE",
description="a slot with this role connects a relationship to a node that is not subject/object/predicate",
)
_defn = EnumDefinition(
name="RelationalRoleEnum",
description="enumeration of roles a slot on a relationship class can play",
)
class AliasPredicateEnum(EnumDefinitionImpl):
"""
permissible values for the relationship between an element and an alias
"""
EXACT_SYNONYM = PermissibleValue(text="EXACT_SYNONYM", meaning=SKOS["exactMatch"])
RELATED_SYNONYM = PermissibleValue(text="RELATED_SYNONYM", meaning=SKOS["relatedMatch"])
BROAD_SYNONYM = PermissibleValue(text="BROAD_SYNONYM", meaning=SKOS["broaderMatch"])
NARROW_SYNONYM = PermissibleValue(text="NARROW_SYNONYM", meaning=SKOS["narrowerMatch"])
_defn = EnumDefinition(
name="AliasPredicateEnum",
description="permissible values for the relationship between an element and an alias",
)
class ObligationLevelEnum(EnumDefinitionImpl):
"""
The level of obligation or recommendation strength for a metadata element
"""
REQUIRED = PermissibleValue(
text="REQUIRED", description="The metadata element is required to be present in the model"
)
RECOMMENDED = PermissibleValue(
text="RECOMMENDED", description="The metadata element is recommended to be present in the model"
)
OPTIONAL = PermissibleValue(
text="OPTIONAL", description="The metadata element is optional to be present in the model"
)
EXAMPLE = PermissibleValue(text="EXAMPLE", description="The metadata element is an example of how to use the model")
DISCOURAGED = PermissibleValue(
text="DISCOURAGED", description="The metadata element is allowed but discouraged to be present in the model"
)
_defn = EnumDefinition(
name="ObligationLevelEnum",
description="The level of obligation or recommendation strength for a metadata element",
)
# Slots
class slots:
pass
slots.name = Slot(
uri=RDFS.label,
name="name",
curie=RDFS.curie("label"),
model_uri=LINKML.name,
domain=Element,
range=Union[str, ElementName],
)
slots.title = Slot(
uri=DCTERMS.title,
name="title",
curie=DCTERMS.curie("title"),
model_uri=LINKML.title,
domain=Element,
range=Optional[str],
)
slots.conforms_to = Slot(
uri=DCTERMS.conformsTo,
name="conforms_to",
curie=DCTERMS.curie("conformsTo"),
model_uri=LINKML.conforms_to,
domain=Element,
range=Optional[str],
)
slots.implements = Slot(
uri=LINKML.implements,
name="implements",
curie=LINKML.curie("implements"),
model_uri=LINKML.implements,
domain=Element,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.instantiates = Slot(
uri=LINKML.instantiates,
name="instantiates",
curie=LINKML.curie("instantiates"),
model_uri=LINKML.instantiates,
domain=Element,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.categories = Slot(
uri=DCTERMS.subject,
name="categories",
curie=DCTERMS.curie("subject"),
model_uri=LINKML.categories,
domain=None,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.keywords = Slot(
uri=SCHEMA.keywords,
name="keywords",
curie=SCHEMA.curie("keywords"),
model_uri=LINKML.keywords,
domain=Element,
range=Optional[Union[str, list[str]]],
)
slots.definition_uri = Slot(
uri=LINKML.definition_uri,
name="definition_uri",
curie=LINKML.curie("definition_uri"),
model_uri=LINKML.definition_uri,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.id_prefixes = Slot(
uri=LINKML.id_prefixes,
name="id_prefixes",
curie=LINKML.curie("id_prefixes"),
model_uri=LINKML.id_prefixes,
domain=Element,
range=Optional[Union[Union[str, NCName], list[Union[str, NCName]]]],
)
slots.id_prefixes_are_closed = Slot(
uri=LINKML.id_prefixes_are_closed,
name="id_prefixes_are_closed",
curie=LINKML.curie("id_prefixes_are_closed"),
model_uri=LINKML.id_prefixes_are_closed,
domain=Element,
range=Optional[Union[bool, Bool]],
)
slots.description = Slot(
uri=SKOS.definition,
name="description",
curie=SKOS.curie("definition"),
model_uri=LINKML.description,
domain=Element,
range=Optional[str],
)
slots.structured_aliases = Slot(
uri=SKOSXL.altLabel,
name="structured_aliases",
curie=SKOSXL.curie("altLabel"),
model_uri=LINKML.structured_aliases,
domain=None,
range=Optional[Union[Union[dict, StructuredAlias], list[Union[dict, StructuredAlias]]]],
)
slots.aliases = Slot(
uri=SKOS.altLabel,
name="aliases",
curie=SKOS.curie("altLabel"),
model_uri=LINKML.aliases,
domain=Element,
range=Optional[Union[str, list[str]]],
)
slots.deprecated = Slot(
uri=LINKML.deprecated,
name="deprecated",
curie=LINKML.curie("deprecated"),
model_uri=LINKML.deprecated,
domain=Element,
range=Optional[str],
)
slots.todos = Slot(
uri=LINKML.todos,
name="todos",
curie=LINKML.curie("todos"),
model_uri=LINKML.todos,
domain=Element,
range=Optional[Union[str, list[str]]],
)
slots.notes = Slot(
uri=SKOS.editorialNote,
name="notes",
curie=SKOS.curie("editorialNote"),
model_uri=LINKML.notes,
domain=Element,
range=Optional[Union[str, list[str]]],
)
slots.comments = Slot(
uri=SKOS.note,
name="comments",
curie=SKOS.curie("note"),
model_uri=LINKML.comments,
domain=Element,
range=Optional[Union[str, list[str]]],
)
slots.in_subset = Slot(
uri=OIO.inSubset,
name="in_subset",
curie=OIO.curie("inSubset"),
model_uri=LINKML.in_subset,
domain=Element,
range=Optional[Union[Union[str, SubsetDefinitionName], list[Union[str, SubsetDefinitionName]]]],
)
slots.from_schema = Slot(
uri=SKOS.inScheme,
name="from_schema",
curie=SKOS.curie("inScheme"),
model_uri=LINKML.from_schema,
domain=Element,
range=Optional[Union[str, URI]],
)
slots.imported_from = Slot(
uri=LINKML.imported_from,
name="imported_from",
curie=LINKML.curie("imported_from"),
model_uri=LINKML.imported_from,
domain=Element,
range=Optional[str],
)
slots.see_also = Slot(
uri=RDFS.seeAlso,
name="see_also",
curie=RDFS.curie("seeAlso"),
model_uri=LINKML.see_also,
domain=Element,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.owned_by = Slot(
uri=LINKML.owned_by,
name="owned_by",
curie=LINKML.curie("owned_by"),
model_uri=LINKML.owned_by,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.created_by = Slot(
uri=PAV.createdBy,
name="created_by",
curie=PAV.curie("createdBy"),
model_uri=LINKML.created_by,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.contributors = Slot(
uri=DCTERMS.contributor,
name="contributors",
curie=DCTERMS.curie("contributor"),
model_uri=LINKML.contributors,
domain=Element,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.created_on = Slot(
uri=PAV.createdOn,
name="created_on",
curie=PAV.curie("createdOn"),
model_uri=LINKML.created_on,
domain=Element,
range=Optional[Union[str, XSDDateTime]],
)
slots.last_updated_on = Slot(
uri=PAV.lastUpdatedOn,
name="last_updated_on",
curie=PAV.curie("lastUpdatedOn"),
model_uri=LINKML.last_updated_on,
domain=Element,
range=Optional[Union[str, XSDDateTime]],
)
slots.modified_by = Slot(
uri=OSLC.modifiedBy,
name="modified_by",
curie=OSLC.curie("modifiedBy"),
model_uri=LINKML.modified_by,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.status = Slot(
uri=BIBO.status,
name="status",
curie=BIBO.curie("status"),
model_uri=LINKML.status,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.literal_form = Slot(
uri=SKOSXL.literalForm,
name="literal_form",
curie=SKOSXL.curie("literalForm"),
model_uri=LINKML.literal_form,
domain=StructuredAlias,
range=str,
)
slots.alias_predicate = Slot(
uri=RDF.predicate,
name="alias_predicate",
curie=RDF.curie("predicate"),
model_uri=LINKML.alias_predicate,
domain=StructuredAlias,
range=Optional[Union[str, "AliasPredicateEnum"]],
)
slots.alias_contexts = Slot(
uri=LINKML.contexts,
name="alias_contexts",
curie=LINKML.curie("contexts"),
model_uri=LINKML.alias_contexts,
domain=StructuredAlias,
range=Optional[Union[Union[str, URI], list[Union[str, URI]]]],
)
slots.in_language = Slot(
uri=SCHEMA.inLanguage,
name="in_language",
curie=SCHEMA.curie("inLanguage"),
model_uri=LINKML.in_language,
domain=None,
range=Optional[str],
)
slots.source = Slot(
uri=DCTERMS.source,
name="source",
curie=DCTERMS.curie("source"),
model_uri=LINKML.source,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.publisher = Slot(
uri=DCTERMS.publisher,
name="publisher",
curie=DCTERMS.curie("publisher"),
model_uri=LINKML.publisher,
domain=Element,
range=Optional[Union[str, URIorCURIE]],
)
slots.is_a = Slot(
uri=LINKML.is_a,
name="is_a",
curie=LINKML.curie("is_a"),
model_uri=LINKML.is_a,
domain=None,
range=Optional[Union[str, DefinitionName]],
)
slots.abstract = Slot(
uri=LINKML.abstract,
name="abstract",
curie=LINKML.curie("abstract"),
model_uri=LINKML.abstract,
domain=Definition,
range=Optional[Union[bool, Bool]],
)
slots.mixin = Slot(
uri=LINKML.mixin,
name="mixin",
curie=LINKML.curie("mixin"),
model_uri=LINKML.mixin,
domain=Definition,
range=Optional[Union[bool, Bool]],
)
slots.mixins = Slot(
uri=LINKML.mixins,
name="mixins",
curie=LINKML.curie("mixins"),
model_uri=LINKML.mixins,
domain=None,
range=Optional[Union[Union[str, DefinitionName], list[Union[str, DefinitionName]]]],
)
slots.apply_to = Slot(
uri=LINKML.apply_to,
name="apply_to",
curie=LINKML.curie("apply_to"),
model_uri=LINKML.apply_to,
domain=Definition,
range=Optional[Union[Union[str, DefinitionName], list[Union[str, DefinitionName]]]],
)
slots.values_from = Slot(
uri=LINKML.values_from,
name="values_from",
curie=LINKML.curie("values_from"),
model_uri=LINKML.values_from,
domain=Definition,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.code_set = Slot(
uri=LINKML.code_set,
name="code_set",
curie=LINKML.curie("code_set"),
model_uri=LINKML.code_set,
domain=EnumExpression,
range=Optional[Union[str, URIorCURIE]],
)
slots.code_set_version = Slot(
uri=LINKML.code_set_version,
name="code_set_version",
curie=LINKML.curie("code_set_version"),
model_uri=LINKML.code_set_version,
domain=EnumExpression,
range=Optional[str],
)
slots.code_set_tag = Slot(
uri=LINKML.code_set_tag,
name="code_set_tag",
curie=LINKML.curie("code_set_tag"),
model_uri=LINKML.code_set_tag,
domain=EnumExpression,
range=Optional[str],
)
slots.pv_formula = Slot(
uri=LINKML.pv_formula,
name="pv_formula",
curie=LINKML.curie("pv_formula"),
model_uri=LINKML.pv_formula,
domain=None,
range=Optional[Union[str, "PvFormulaOptions"]],
)
slots.permissible_values = Slot(
uri=LINKML.permissible_values,
name="permissible_values",
curie=LINKML.curie("permissible_values"),
model_uri=LINKML.permissible_values,
domain=EnumExpression,
range=Optional[
Union[
dict[Union[str, PermissibleValueText], Union[dict, "PermissibleValue"]],
list[Union[dict, "PermissibleValue"]],
]
],
)
slots.enum_uri = Slot(
uri=LINKML.enum_uri,
name="enum_uri",
curie=LINKML.curie("enum_uri"),
model_uri=LINKML.enum_uri,
domain=EnumDefinition,
range=Optional[Union[str, URIorCURIE]],
)
slots.include = Slot(
uri=LINKML.include,
name="include",
curie=LINKML.curie("include"),
model_uri=LINKML.include,
domain=EnumExpression,
range=Optional[Union[Union[dict, "AnonymousEnumExpression"], list[Union[dict, "AnonymousEnumExpression"]]]],
)
slots.minus = Slot(
uri=LINKML.minus,
name="minus",
curie=LINKML.curie("minus"),
model_uri=LINKML.minus,
domain=EnumExpression,
range=Optional[Union[Union[dict, "AnonymousEnumExpression"], list[Union[dict, "AnonymousEnumExpression"]]]],
)
slots.inherits = Slot(
uri=LINKML.inherits,
name="inherits",
curie=LINKML.curie("inherits"),
model_uri=LINKML.inherits,
domain=EnumExpression,
range=Optional[Union[Union[str, EnumDefinitionName], list[Union[str, EnumDefinitionName]]]],
)
slots.matches = Slot(
uri=LINKML.matches,
name="matches",
curie=LINKML.curie("matches"),
model_uri=LINKML.matches,
domain=EnumExpression,
range=Optional[Union[dict, "MatchQuery"]],
)
slots.identifier_pattern = Slot(
uri=LINKML.identifier_pattern,
name="identifier_pattern",
curie=LINKML.curie("identifier_pattern"),
model_uri=LINKML.identifier_pattern,
domain=MatchQuery,
range=Optional[str],
)
slots.concepts = Slot(
uri=LINKML.concepts,
name="concepts",
curie=LINKML.curie("concepts"),
model_uri=LINKML.concepts,
domain=EnumExpression,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.reachable_from = Slot(
uri=LINKML.reachable_from,
name="reachable_from",
curie=LINKML.curie("reachable_from"),
model_uri=LINKML.reachable_from,
domain=EnumExpression,
range=Optional[Union[dict, "ReachabilityQuery"]],
)
slots.source_ontology = Slot(
uri=LINKML.source_ontology,
name="source_ontology",
curie=LINKML.curie("source_ontology"),
model_uri=LINKML.source_ontology,
domain=None,
range=Optional[Union[str, URIorCURIE]],
)
slots.is_direct = Slot(
uri=LINKML.is_direct,
name="is_direct",
curie=LINKML.curie("is_direct"),
model_uri=LINKML.is_direct,
domain=ReachabilityQuery,
range=Optional[Union[bool, Bool]],
)
slots.traverse_up = Slot(
uri=LINKML.traverse_up,
name="traverse_up",
curie=LINKML.curie("traverse_up"),
model_uri=LINKML.traverse_up,
domain=ReachabilityQuery,
range=Optional[Union[bool, Bool]],
)
slots.include_self = Slot(
uri=LINKML.include_self,
name="include_self",
curie=LINKML.curie("include_self"),
model_uri=LINKML.include_self,
domain=ReachabilityQuery,
range=Optional[Union[bool, Bool]],
)
slots.relationship_types = Slot(
uri=LINKML.relationship_types,
name="relationship_types",
curie=LINKML.curie("relationship_types"),
model_uri=LINKML.relationship_types,
domain=ReachabilityQuery,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.source_nodes = Slot(
uri=LINKML.source_nodes,
name="source_nodes",
curie=LINKML.curie("source_nodes"),
model_uri=LINKML.source_nodes,
domain=ReachabilityQuery,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.text = Slot(
uri=LINKML.text,
name="text",
curie=LINKML.curie("text"),
model_uri=LINKML.text,
domain=PermissibleValue,
range=Union[str, PermissibleValueText],
)
slots.meaning = Slot(
uri=LINKML.meaning,
name="meaning",
curie=LINKML.curie("meaning"),
model_uri=LINKML.meaning,
domain=PermissibleValue,
range=Optional[Union[str, URIorCURIE]],
)
slots.id = Slot(
uri=LINKML.id,
name="id",
curie=LINKML.curie("id"),
model_uri=LINKML.id,
domain=SchemaDefinition,
range=Union[str, URI],
)
slots.emit_prefixes = Slot(
uri=LINKML.emit_prefixes,
name="emit_prefixes",
curie=LINKML.curie("emit_prefixes"),
model_uri=LINKML.emit_prefixes,
domain=SchemaDefinition,
range=Optional[Union[Union[str, NCName], list[Union[str, NCName]]]],
)
slots.version = Slot(
uri=PAV.version,
name="version",
curie=PAV.curie("version"),
model_uri=LINKML.version,
domain=SchemaDefinition,
range=Optional[str],
)
slots.imports = Slot(
uri=LINKML.imports,
name="imports",
curie=LINKML.curie("imports"),
model_uri=LINKML.imports,
domain=SchemaDefinition,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.structured_imports = Slot(
uri=LINKML.structured_imports,
name="structured_imports",
curie=LINKML.curie("structured_imports"),
model_uri=LINKML.structured_imports,
domain=SchemaDefinition,
range=Optional[Union[Union[dict, "ImportExpression"], list[Union[dict, "ImportExpression"]]]],
)
slots.license = Slot(
uri=DCTERMS.license,
name="license",
curie=DCTERMS.curie("license"),
model_uri=LINKML.license,
domain=SchemaDefinition,
range=Optional[str],
)
slots.default_curi_maps = Slot(
uri=LINKML.default_curi_maps,
name="default_curi_maps",
curie=LINKML.curie("default_curi_maps"),
model_uri=LINKML.default_curi_maps,
domain=SchemaDefinition,
range=Optional[Union[str, list[str]]],
)
slots.default_prefix = Slot(
uri=LINKML.default_prefix,
name="default_prefix",
curie=LINKML.curie("default_prefix"),
model_uri=LINKML.default_prefix,
domain=SchemaDefinition,
range=Optional[str],
)
slots.default_range = Slot(
uri=LINKML.default_range,
name="default_range",
curie=LINKML.curie("default_range"),
model_uri=LINKML.default_range,
domain=SchemaDefinition,
range=Optional[Union[str, TypeDefinitionName]],
)
slots.subsets = Slot(
uri=LINKML.subsets,
name="subsets",
curie=LINKML.curie("subsets"),
model_uri=LINKML.subsets,
domain=SchemaDefinition,
range=Optional[
Union[
dict[Union[str, SubsetDefinitionName], Union[dict, "SubsetDefinition"]],
list[Union[dict, "SubsetDefinition"]],
]
],
)
slots.types = Slot(
uri=LINKML.types,
name="types",
curie=LINKML.curie("types"),
model_uri=LINKML.types,
domain=SchemaDefinition,
range=Optional[
Union[dict[Union[str, TypeDefinitionName], Union[dict, "TypeDefinition"]], list[Union[dict, "TypeDefinition"]]]
],
)
slots.enums = Slot(
uri=LINKML.enums,
name="enums",
curie=LINKML.curie("enums"),
model_uri=LINKML.enums,
domain=SchemaDefinition,
range=Optional[
Union[dict[Union[str, EnumDefinitionName], Union[dict, "EnumDefinition"]], list[Union[dict, "EnumDefinition"]]]
],
)
slots.slot_definitions = Slot(
uri=LINKML.slots,
name="slot_definitions",
curie=LINKML.curie("slots"),
model_uri=LINKML.slot_definitions,
domain=SchemaDefinition,
range=Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, "SlotDefinition"]], list[Union[dict, "SlotDefinition"]]]
],
)
slots.classes = Slot(
uri=LINKML.classes,
name="classes",
curie=LINKML.curie("classes"),
model_uri=LINKML.classes,
domain=SchemaDefinition,
range=Optional[
Union[
dict[Union[str, ClassDefinitionName], Union[dict, "ClassDefinition"]], list[Union[dict, "ClassDefinition"]]
]
],
)
slots.metamodel_version = Slot(
uri=LINKML.metamodel_version,
name="metamodel_version",
curie=LINKML.curie("metamodel_version"),
model_uri=LINKML.metamodel_version,
domain=SchemaDefinition,
range=Optional[str],
)
slots.source_file = Slot(
uri=LINKML.source_file,
name="source_file",
curie=LINKML.curie("source_file"),
model_uri=LINKML.source_file,
domain=SchemaDefinition,
range=Optional[str],
)
slots.source_file_date = Slot(
uri=LINKML.source_file_date,
name="source_file_date",
curie=LINKML.curie("source_file_date"),
model_uri=LINKML.source_file_date,
domain=SchemaDefinition,
range=Optional[Union[str, XSDDateTime]],
)
slots.source_file_size = Slot(
uri=LINKML.source_file_size,
name="source_file_size",
curie=LINKML.curie("source_file_size"),
model_uri=LINKML.source_file_size,
domain=SchemaDefinition,
range=Optional[int],
)
slots.generation_date = Slot(
uri=LINKML.generation_date,
name="generation_date",
curie=LINKML.curie("generation_date"),
model_uri=LINKML.generation_date,
domain=SchemaDefinition,
range=Optional[Union[str, XSDDateTime]],
)
slots.slots = Slot(
uri=LINKML.slots,
name="slots",
curie=LINKML.curie("slots"),
model_uri=LINKML.slots,
domain=ClassDefinition,
range=Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]],
)
slots.slot_usage = Slot(
uri=LINKML.slot_usage,
name="slot_usage",
curie=LINKML.curie("slot_usage"),
model_uri=LINKML.slot_usage,
domain=ClassDefinition,
range=Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
],
)
slots.enum_range = Slot(
uri=LINKML.enum_range,
name="enum_range",
curie=LINKML.curie("enum_range"),
model_uri=LINKML.enum_range,
domain=None,
range=Optional[Union[dict, EnumExpression]],
)
slots.range_expression = Slot(
uri=LINKML.range_expression,
name="range_expression",
curie=LINKML.curie("range_expression"),
model_uri=LINKML.range_expression,
domain=None,
range=Optional[Union[dict, "AnonymousClassExpression"]],
)
slots.boolean_slot = Slot(
uri=LINKML.boolean_slot,
name="boolean_slot",
curie=LINKML.curie("boolean_slot"),
model_uri=LINKML.boolean_slot,
domain=None,
range=Optional[Union[Union[dict, Expression], list[Union[dict, Expression]]]],
)
slots.any_of = Slot(
uri=LINKML.any_of,
name="any_of",
curie=LINKML.curie("any_of"),
model_uri=LINKML.any_of,
domain=None,
range=Optional[Union[Union[dict, Expression], list[Union[dict, Expression]]]],
)
slots.exactly_one_of = Slot(
uri=LINKML.exactly_one_of,
name="exactly_one_of",
curie=LINKML.curie("exactly_one_of"),
model_uri=LINKML.exactly_one_of,
domain=None,
range=Optional[Union[Union[dict, Expression], list[Union[dict, Expression]]]],
)
slots.none_of = Slot(
uri=LINKML.none_of,
name="none_of",
curie=LINKML.curie("none_of"),
model_uri=LINKML.none_of,
domain=None,
range=Optional[Union[Union[dict, Expression], list[Union[dict, Expression]]]],
)
slots.all_of = Slot(
uri=LINKML.all_of,
name="all_of",
curie=LINKML.curie("all_of"),
model_uri=LINKML.all_of,
domain=None,
range=Optional[Union[Union[dict, Expression], list[Union[dict, Expression]]]],
)
slots.preconditions = Slot(
uri=SH.condition,
name="preconditions",
curie=SH.curie("condition"),
model_uri=LINKML.preconditions,
domain=None,
range=Optional[Union[dict, AnonymousClassExpression]],
)
slots.postconditions = Slot(
uri=LINKML.postconditions,
name="postconditions",
curie=LINKML.curie("postconditions"),
model_uri=LINKML.postconditions,
domain=None,
range=Optional[Union[dict, AnonymousClassExpression]],
)
slots.elseconditions = Slot(
uri=LINKML.elseconditions,
name="elseconditions",
curie=LINKML.curie("elseconditions"),
model_uri=LINKML.elseconditions,
domain=None,
range=Optional[Union[dict, AnonymousClassExpression]],
)
slots.bidirectional = Slot(
uri=LINKML.bidirectional,
name="bidirectional",
curie=LINKML.curie("bidirectional"),
model_uri=LINKML.bidirectional,
domain=None,
range=Optional[Union[bool, Bool]],
)
slots.open_world = Slot(
uri=LINKML.open_world,
name="open_world",
curie=LINKML.curie("open_world"),
model_uri=LINKML.open_world,
domain=None,
range=Optional[Union[bool, Bool]],
)
slots.rank = Slot(
uri=SH.order, name="rank", curie=SH.curie("order"), model_uri=LINKML.rank, domain=None, range=Optional[int]
)
slots.deactivated = Slot(
uri=SH.deactivated,
name="deactivated",
curie=SH.curie("deactivated"),
model_uri=LINKML.deactivated,
domain=None,
range=Optional[Union[bool, Bool]],
)
slots.rules = Slot(
uri=SH.rule,
name="rules",
curie=SH.curie("rule"),
model_uri=LINKML.rules,
domain=ClassDefinition,
range=Optional[Union[Union[dict, "ClassRule"], list[Union[dict, "ClassRule"]]]],
)
slots.classification_rules = Slot(
uri=LINKML.classification_rules,
name="classification_rules",
curie=LINKML.curie("classification_rules"),
model_uri=LINKML.classification_rules,
domain=ClassDefinition,
range=Optional[Union[Union[dict, AnonymousClassExpression], list[Union[dict, AnonymousClassExpression]]]],
)
slots.slot_conditions = Slot(
uri=LINKML.slot_conditions,
name="slot_conditions",
curie=LINKML.curie("slot_conditions"),
model_uri=LINKML.slot_conditions,
domain=None,
range=Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
],
)
slots.attributes = Slot(
uri=LINKML.attributes,
name="attributes",
curie=LINKML.curie("attributes"),
model_uri=LINKML.attributes,
domain=ClassDefinition,
range=Optional[
Union[dict[Union[str, SlotDefinitionName], Union[dict, SlotDefinition]], list[Union[dict, SlotDefinition]]]
],
)
slots.class_uri = Slot(
uri=LINKML.class_uri,
name="class_uri",
curie=LINKML.curie("class_uri"),
model_uri=LINKML.class_uri,
domain=ClassDefinition,
range=Optional[Union[str, URIorCURIE]],
)
slots.subclass_of = Slot(
uri=LINKML.subclass_of,
name="subclass_of",
curie=LINKML.curie("subclass_of"),
model_uri=LINKML.subclass_of,
domain=ClassDefinition,
range=Optional[Union[str, URIorCURIE]],
)
slots.defining_slots = Slot(
uri=LINKML.defining_slots,
name="defining_slots",
curie=LINKML.curie("defining_slots"),
model_uri=LINKML.defining_slots,
domain=ClassDefinition,
range=Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]],
)
slots.union_of = Slot(
uri=LINKML.union_of,
name="union_of",
curie=LINKML.curie("union_of"),
model_uri=LINKML.union_of,
domain=Element,
range=Optional[Union[Union[str, ElementName], list[Union[str, ElementName]]]],
)
slots.tree_root = Slot(
uri=LINKML.tree_root,
name="tree_root",
curie=LINKML.curie("tree_root"),
model_uri=LINKML.tree_root,
domain=ClassDefinition,
range=Optional[Union[bool, Bool]],
)
slots.unique_keys = Slot(
uri=LINKML.unique_keys,
name="unique_keys",
curie=LINKML.curie("unique_keys"),
model_uri=LINKML.unique_keys,
domain=ClassDefinition,
range=Optional[
Union[dict[Union[str, UniqueKeyUniqueKeyName], Union[dict, "UniqueKey"]], list[Union[dict, "UniqueKey"]]]
],
)
slots.unique_key_name = Slot(
uri=LINKML.unique_key_name,
name="unique_key_name",
curie=LINKML.curie("unique_key_name"),
model_uri=LINKML.unique_key_name,
domain=UniqueKey,
range=Union[str, UniqueKeyUniqueKeyName],
)
slots.consider_nulls_inequal = Slot(
uri=LINKML.consider_nulls_inequal,
name="consider_nulls_inequal",
curie=LINKML.curie("consider_nulls_inequal"),
model_uri=LINKML.consider_nulls_inequal,
domain=UniqueKey,
range=Optional[Union[bool, Bool]],
)
slots.unique_key_slots = Slot(
uri=LINKML.unique_key_slots,
name="unique_key_slots",
curie=LINKML.curie("unique_key_slots"),
model_uri=LINKML.unique_key_slots,
domain=UniqueKey,
range=Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]],
)
slots.slot_names_unique = Slot(
uri=LINKML.slot_names_unique,
name="slot_names_unique",
curie=LINKML.curie("slot_names_unique"),
model_uri=LINKML.slot_names_unique,
domain=Definition,
range=Optional[Union[bool, Bool]],
)
slots.domain = Slot(
uri=LINKML.domain,
name="domain",
curie=LINKML.curie("domain"),
model_uri=LINKML.domain,
domain=SlotDefinition,
range=Optional[Union[str, ClassDefinitionName]],
)
slots.range = Slot(
uri=LINKML.range,
name="range",
curie=LINKML.curie("range"),
model_uri=LINKML.range,
domain=SlotDefinition,
range=Optional[Union[str, ElementName]],
)
slots.slot_uri = Slot(
uri=LINKML.slot_uri,
name="slot_uri",
curie=LINKML.curie("slot_uri"),
model_uri=LINKML.slot_uri,
domain=SlotDefinition,
range=Optional[Union[str, URIorCURIE]],
)
slots.multivalued = Slot(
uri=LINKML.multivalued,
name="multivalued",
curie=LINKML.curie("multivalued"),
model_uri=LINKML.multivalued,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.array = Slot(
uri=LINKML.array,
name="array",
curie=LINKML.curie("array"),
model_uri=LINKML.array,
domain=SlotDefinition,
range=Optional[Union[dict, "ArrayExpression"]],
)
slots.dimensions = Slot(
uri=LINKML.dimensions,
name="dimensions",
curie=LINKML.curie("dimensions"),
model_uri=LINKML.dimensions,
domain=ArrayExpression,
range=Optional[Union[Union[dict, "DimensionExpression"], list[Union[dict, "DimensionExpression"]]]],
)
slots.minimum_number_dimensions = Slot(
uri=LINKML.minimum_number_dimensions,
name="minimum_number_dimensions",
curie=LINKML.curie("minimum_number_dimensions"),
model_uri=LINKML.minimum_number_dimensions,
domain=ArrayExpression,
range=Optional[int],
)
slots.maximum_number_dimensions = Slot(
uri=LINKML.maximum_number_dimensions,
name="maximum_number_dimensions",
curie=LINKML.curie("maximum_number_dimensions"),
model_uri=LINKML.maximum_number_dimensions,
domain=ArrayExpression,
range=Optional[Union[dict, Anything]],
)
slots.exact_number_dimensions = Slot(
uri=LINKML.exact_number_dimensions,
name="exact_number_dimensions",
curie=LINKML.curie("exact_number_dimensions"),
model_uri=LINKML.exact_number_dimensions,
domain=ArrayExpression,
range=Optional[int],
)
slots.inherited = Slot(
uri=LINKML.inherited,
name="inherited",
curie=LINKML.curie("inherited"),
model_uri=LINKML.inherited,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.readonly = Slot(
uri=LINKML.readonly,
name="readonly",
curie=LINKML.curie("readonly"),
model_uri=LINKML.readonly,
domain=SlotDefinition,
range=Optional[str],
)
slots.ifabsent = Slot(
uri=LINKML.ifabsent,
name="ifabsent",
curie=LINKML.curie("ifabsent"),
model_uri=LINKML.ifabsent,
domain=SlotDefinition,
range=Optional[str],
)
slots.implicit_prefix = Slot(
uri=LINKML.implicit_prefix,
name="implicit_prefix",
curie=LINKML.curie("implicit_prefix"),
model_uri=LINKML.implicit_prefix,
domain=None,
range=Optional[str],
)
slots.value_specification_constant = Slot(
uri=LINKML.value_specification_constant,
name="value_specification_constant",
curie=LINKML.curie("value_specification_constant"),
model_uri=LINKML.value_specification_constant,
domain=None,
range=Optional[str],
)
slots.list_value_specification_constant = Slot(
uri=LINKML.list_value_specification_constant,
name="list_value_specification_constant",
curie=LINKML.curie("list_value_specification_constant"),
model_uri=LINKML.list_value_specification_constant,
domain=None,
range=Optional[str],
)
slots.value_presence = Slot(
uri=LINKML.value_presence,
name="value_presence",
curie=LINKML.curie("value_presence"),
model_uri=LINKML.value_presence,
domain=SlotDefinition,
range=Optional[Union[str, "PresenceEnum"]],
)
slots.equals_string = Slot(
uri=LINKML.equals_string,
name="equals_string",
curie=LINKML.curie("equals_string"),
model_uri=LINKML.equals_string,
domain=None,
range=Optional[str],
)
slots.equals_number = Slot(
uri=LINKML.equals_number,
name="equals_number",
curie=LINKML.curie("equals_number"),
model_uri=LINKML.equals_number,
domain=None,
range=Optional[int],
)
slots.equals_expression = Slot(
uri=LINKML.equals_expression,
name="equals_expression",
curie=LINKML.curie("equals_expression"),
model_uri=LINKML.equals_expression,
domain=None,
range=Optional[str],
)
slots.exact_cardinality = Slot(
uri=LINKML.exact_cardinality,
name="exact_cardinality",
curie=LINKML.curie("exact_cardinality"),
model_uri=LINKML.exact_cardinality,
domain=None,
range=Optional[int],
)
slots.minimum_cardinality = Slot(
uri=LINKML.minimum_cardinality,
name="minimum_cardinality",
curie=LINKML.curie("minimum_cardinality"),
model_uri=LINKML.minimum_cardinality,
domain=None,
range=Optional[int],
)
slots.maximum_cardinality = Slot(
uri=LINKML.maximum_cardinality,
name="maximum_cardinality",
curie=LINKML.curie("maximum_cardinality"),
model_uri=LINKML.maximum_cardinality,
domain=None,
range=Optional[int],
)
slots.equals_string_in = Slot(
uri=LINKML.equals_string_in,
name="equals_string_in",
curie=LINKML.curie("equals_string_in"),
model_uri=LINKML.equals_string_in,
domain=None,
range=Optional[Union[str, list[str]]],
)
slots.equals_number_in = Slot(
uri=LINKML.equals_number_in,
name="equals_number_in",
curie=LINKML.curie("equals_number_in"),
model_uri=LINKML.equals_number_in,
domain=None,
range=Optional[Union[int, list[int]]],
)
slots.has_member = Slot(
uri=LINKML.has_member,
name="has_member",
curie=LINKML.curie("has_member"),
model_uri=LINKML.has_member,
domain=None,
range=Optional[Union[dict, AnonymousSlotExpression]],
)
slots.all_members = Slot(
uri=LINKML.all_members,
name="all_members",
curie=LINKML.curie("all_members"),
model_uri=LINKML.all_members,
domain=None,
range=Optional[Union[dict, AnonymousSlotExpression]],
)
slots.singular_name = Slot(
uri=LINKML.singular_name,
name="singular_name",
curie=LINKML.curie("singular_name"),
model_uri=LINKML.singular_name,
domain=SlotDefinition,
range=Optional[str],
)
slots.required = Slot(
uri=LINKML.required,
name="required",
curie=LINKML.curie("required"),
model_uri=LINKML.required,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.recommended = Slot(
uri=LINKML.recommended,
name="recommended",
curie=LINKML.curie("recommended"),
model_uri=LINKML.recommended,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.inapplicable = Slot(
uri=LINKML.inapplicable,
name="inapplicable",
curie=LINKML.curie("inapplicable"),
model_uri=LINKML.inapplicable,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.inlined = Slot(
uri=LINKML.inlined,
name="inlined",
curie=LINKML.curie("inlined"),
model_uri=LINKML.inlined,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.inlined_as_list = Slot(
uri=LINKML.inlined_as_list,
name="inlined_as_list",
curie=LINKML.curie("inlined_as_list"),
model_uri=LINKML.inlined_as_list,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.inlined_as_simple_dict = Slot(
uri=LINKML.inlined_as_simple_dict,
name="inlined_as_simple_dict",
curie=LINKML.curie("inlined_as_simple_dict"),
model_uri=LINKML.inlined_as_simple_dict,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.list_elements_ordered = Slot(
uri=LINKML.list_elements_ordered,
name="list_elements_ordered",
curie=LINKML.curie("list_elements_ordered"),
model_uri=LINKML.list_elements_ordered,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.list_elements_unique = Slot(
uri=LINKML.list_elements_unique,
name="list_elements_unique",
curie=LINKML.curie("list_elements_unique"),
model_uri=LINKML.list_elements_unique,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.shared = Slot(
uri=LINKML.shared,
name="shared",
curie=LINKML.curie("shared"),
model_uri=LINKML.shared,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.key = Slot(
uri=LINKML.key,
name="key",
curie=LINKML.curie("key"),
model_uri=LINKML.key,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.identifier = Slot(
uri=LINKML.identifier,
name="identifier",
curie=LINKML.curie("identifier"),
model_uri=LINKML.identifier,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.designates_type = Slot(
uri=LINKML.designates_type,
name="designates_type",
curie=LINKML.curie("designates_type"),
model_uri=LINKML.designates_type,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.alias = Slot(
uri=SKOS.prefLabel,
name="alias",
curie=SKOS.curie("prefLabel"),
model_uri=LINKML.alias,
domain=SlotDefinition,
range=Optional[str],
)
slots.owner = Slot(
uri=LINKML.owner,
name="owner",
curie=LINKML.curie("owner"),
model_uri=LINKML.owner,
domain=SlotDefinition,
range=Optional[Union[str, DefinitionName]],
)
slots.domain_of = Slot(
uri=LINKML.domain_of,
name="domain_of",
curie=LINKML.curie("domain_of"),
model_uri=LINKML.domain_of,
domain=SlotDefinition,
range=Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]],
)
slots.is_usage_slot = Slot(
uri=LINKML.is_usage_slot,
name="is_usage_slot",
curie=LINKML.curie("is_usage_slot"),
model_uri=LINKML.is_usage_slot,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.usage_slot_name = Slot(
uri=LINKML.usage_slot_name,
name="usage_slot_name",
curie=LINKML.curie("usage_slot_name"),
model_uri=LINKML.usage_slot_name,
domain=SlotDefinition,
range=Optional[str],
)
slots.subproperty_of = Slot(
uri=RDFS.subPropertyOf,
name="subproperty_of",
curie=RDFS.curie("subPropertyOf"),
model_uri=LINKML.subproperty_of,
domain=SlotDefinition,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.disjoint_with = Slot(
uri=LINKML.disjoint_with,
name="disjoint_with",
curie=LINKML.curie("disjoint_with"),
model_uri=LINKML.disjoint_with,
domain=Definition,
range=Optional[Union[Union[str, DefinitionName], list[Union[str, DefinitionName]]]],
)
slots.children_are_mutually_disjoint = Slot(
uri=LINKML.children_are_mutually_disjoint,
name="children_are_mutually_disjoint",
curie=LINKML.curie("children_are_mutually_disjoint"),
model_uri=LINKML.children_are_mutually_disjoint,
domain=Definition,
range=Optional[Union[bool, Bool]],
)
slots.relational_logical_characteristic = Slot(
uri=LINKML.relational_logical_characteristic,
name="relational_logical_characteristic",
curie=LINKML.curie("relational_logical_characteristic"),
model_uri=LINKML.relational_logical_characteristic,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.symmetric = Slot(
uri=LINKML.symmetric,
name="symmetric",
curie=LINKML.curie("symmetric"),
model_uri=LINKML.symmetric,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.asymmetric = Slot(
uri=LINKML.asymmetric,
name="asymmetric",
curie=LINKML.curie("asymmetric"),
model_uri=LINKML.asymmetric,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.reflexive = Slot(
uri=LINKML.reflexive,
name="reflexive",
curie=LINKML.curie("reflexive"),
model_uri=LINKML.reflexive,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.irreflexive = Slot(
uri=LINKML.irreflexive,
name="irreflexive",
curie=LINKML.curie("irreflexive"),
model_uri=LINKML.irreflexive,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.locally_reflexive = Slot(
uri=LINKML.locally_reflexive,
name="locally_reflexive",
curie=LINKML.curie("locally_reflexive"),
model_uri=LINKML.locally_reflexive,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.transitive = Slot(
uri=LINKML.transitive,
name="transitive",
curie=LINKML.curie("transitive"),
model_uri=LINKML.transitive,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.transitive_form_of = Slot(
uri=LINKML.transitive_form_of,
name="transitive_form_of",
curie=LINKML.curie("transitive_form_of"),
model_uri=LINKML.transitive_form_of,
domain=None,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.reflexive_transitive_form_of = Slot(
uri=LINKML.reflexive_transitive_form_of,
name="reflexive_transitive_form_of",
curie=LINKML.curie("reflexive_transitive_form_of"),
model_uri=LINKML.reflexive_transitive_form_of,
domain=None,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.inverse = Slot(
uri=OWL.inverseOf,
name="inverse",
curie=OWL.curie("inverseOf"),
model_uri=LINKML.inverse,
domain=SlotDefinition,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.is_class_field = Slot(
uri=LINKML.is_class_field,
name="is_class_field",
curie=LINKML.curie("is_class_field"),
model_uri=LINKML.is_class_field,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.role = Slot(
uri=LINKML.role,
name="role",
curie=LINKML.curie("role"),
model_uri=LINKML.role,
domain=SlotDefinition,
range=Optional[str],
)
slots.minimum_value = Slot(
uri=LINKML.minimum_value,
name="minimum_value",
curie=LINKML.curie("minimum_value"),
model_uri=LINKML.minimum_value,
domain=SlotDefinition,
range=Optional[Union[dict, Anything]],
)
slots.maximum_value = Slot(
uri=LINKML.maximum_value,
name="maximum_value",
curie=LINKML.curie("maximum_value"),
model_uri=LINKML.maximum_value,
domain=SlotDefinition,
range=Optional[Union[dict, Anything]],
)
slots.interpolated = Slot(
uri=LINKML.interpolated,
name="interpolated",
curie=LINKML.curie("interpolated"),
model_uri=LINKML.interpolated,
domain=PatternExpression,
range=Optional[Union[bool, Bool]],
)
slots.partial_match = Slot(
uri=LINKML.partial_match,
name="partial_match",
curie=LINKML.curie("partial_match"),
model_uri=LINKML.partial_match,
domain=PatternExpression,
range=Optional[Union[bool, Bool]],
)
slots.pattern = Slot(
uri=LINKML.pattern,
name="pattern",
curie=LINKML.curie("pattern"),
model_uri=LINKML.pattern,
domain=Definition,
range=Optional[str],
)
slots.syntax = Slot(
uri=LINKML.syntax,
name="syntax",
curie=LINKML.curie("syntax"),
model_uri=LINKML.syntax,
domain=PatternExpression,
range=Optional[str],
)
slots.structured_pattern = Slot(
uri=LINKML.structured_pattern,
name="structured_pattern",
curie=LINKML.curie("structured_pattern"),
model_uri=LINKML.structured_pattern,
domain=Definition,
range=Optional[Union[dict, "PatternExpression"]],
)
slots.string_serialization = Slot(
uri=LINKML.string_serialization,
name="string_serialization",
curie=LINKML.curie("string_serialization"),
model_uri=LINKML.string_serialization,
domain=Definition,
range=Optional[str],
)
slots.bindings = Slot(
uri=LINKML.bindings,
name="bindings",
curie=LINKML.curie("bindings"),
model_uri=LINKML.bindings,
domain=Element,
range=Optional[Union[Union[dict, "EnumBinding"], list[Union[dict, "EnumBinding"]]]],
)
slots.binds_value_of = Slot(
uri=LINKML.binds_value_of,
name="binds_value_of",
curie=LINKML.curie("binds_value_of"),
model_uri=LINKML.binds_value_of,
domain=EnumBinding,
range=Optional[str],
)
slots.obligation_level = Slot(
uri=LINKML.obligation_level,
name="obligation_level",
curie=LINKML.curie("obligation_level"),
model_uri=LINKML.obligation_level,
domain=None,
range=Optional[Union[str, "ObligationLevelEnum"]],
)
slots.type_mappings = Slot(
uri=LINKML.type_mappings,
name="type_mappings",
curie=LINKML.curie("type_mappings"),
model_uri=LINKML.type_mappings,
domain=None,
range=Optional[Union[Union[str, TypeMappingFramework], list[Union[str, TypeMappingFramework]]]],
)
slots.framework_key = Slot(
uri=LINKML.framework,
name="framework_key",
curie=LINKML.curie("framework"),
model_uri=LINKML.framework_key,
domain=None,
range=URIRef,
)
slots.mapped_type = Slot(
uri=LINKML.type,
name="mapped_type",
curie=LINKML.curie("type"),
model_uri=LINKML.mapped_type,
domain=None,
range=Optional[Union[str, TypeDefinitionName]],
)
slots.typeof = Slot(
uri=LINKML.typeof,
name="typeof",
curie=LINKML.curie("typeof"),
model_uri=LINKML.typeof,
domain=TypeDefinition,
range=Optional[Union[str, TypeDefinitionName]],
)
slots.base = Slot(
uri=LINKML.base,
name="base",
curie=LINKML.curie("base"),
model_uri=LINKML.base,
domain=TypeDefinition,
range=Optional[str],
)
slots.type_uri = Slot(
uri=LINKML.uri,
name="type_uri",
curie=LINKML.curie("uri"),
model_uri=LINKML.type_uri,
domain=TypeDefinition,
range=Optional[Union[str, URIorCURIE]],
)
slots.repr = Slot(
uri=LINKML.repr,
name="repr",
curie=LINKML.curie("repr"),
model_uri=LINKML.repr,
domain=TypeDefinition,
range=Optional[str],
)
slots.alt_description_text = Slot(
uri=LINKML.description,
name="alt_description_text",
curie=LINKML.curie("description"),
model_uri=LINKML.alt_description_text,
domain=AltDescription,
range=str,
)
slots.alt_description_source = Slot(
uri=LINKML.source,
name="alt_description_source",
curie=LINKML.curie("source"),
model_uri=LINKML.alt_description_source,
domain=AltDescription,
range=Union[str, AltDescriptionSource],
)
slots.alt_descriptions = Slot(
uri=LINKML.alt_descriptions,
name="alt_descriptions",
curie=LINKML.curie("alt_descriptions"),
model_uri=LINKML.alt_descriptions,
domain=Element,
range=Optional[
Union[
dict[Union[str, AltDescriptionSource], Union[dict, "AltDescription"]], list[Union[dict, "AltDescription"]]
]
],
)
slots.value = Slot(
uri=SKOS.example,
name="value",
curie=SKOS.curie("example"),
model_uri=LINKML.value,
domain=Example,
range=Optional[str],
)
slots.value_description = Slot(
uri=LINKML.description,
name="value_description",
curie=LINKML.curie("description"),
model_uri=LINKML.value_description,
domain=Example,
range=Optional[str],
)
slots.value_object = Slot(
uri=LINKML.object,
name="value_object",
curie=LINKML.curie("object"),
model_uri=LINKML.value_object,
domain=Example,
range=Optional[Union[dict, Anything]],
)
slots.examples = Slot(
uri=LINKML.examples,
name="examples",
curie=LINKML.curie("examples"),
model_uri=LINKML.examples,
domain=Element,
range=Optional[Union[Union[dict, "Example"], list[Union[dict, "Example"]]]],
)
slots.prefix_prefix = Slot(
uri=SH.prefix,
name="prefix_prefix",
curie=SH.curie("prefix"),
model_uri=LINKML.prefix_prefix,
domain=Prefix,
range=Union[str, PrefixPrefixPrefix],
)
slots.prefix_reference = Slot(
uri=SH.namespace,
name="prefix_reference",
curie=SH.curie("namespace"),
model_uri=LINKML.prefix_reference,
domain=Prefix,
range=Union[str, URI],
)
slots.prefixes = Slot(
uri=SH.declare,
name="prefixes",
curie=SH.curie("declare"),
model_uri=LINKML.prefixes,
domain=SchemaDefinition,
range=Optional[Union[dict[Union[str, PrefixPrefixPrefix], Union[dict, "Prefix"]], list[Union[dict, "Prefix"]]]],
)
slots.setting_key = Slot(
uri=LINKML.setting_key,
name="setting_key",
curie=LINKML.curie("setting_key"),
model_uri=LINKML.setting_key,
domain=Setting,
range=Union[str, SettingSettingKey],
)
slots.setting_value = Slot(
uri=LINKML.setting_value,
name="setting_value",
curie=LINKML.curie("setting_value"),
model_uri=LINKML.setting_value,
domain=Setting,
range=str,
)
slots.settings = Slot(
uri=LINKML.settings,
name="settings",
curie=LINKML.curie("settings"),
model_uri=LINKML.settings,
domain=SchemaDefinition,
range=Optional[Union[dict[Union[str, SettingSettingKey], Union[dict, "Setting"]], list[Union[dict, "Setting"]]]],
)
slots.import_from = Slot(
uri=LINKML.import_from,
name="import_from",
curie=LINKML.curie("import_from"),
model_uri=LINKML.import_from,
domain=ImportExpression,
range=Union[str, URIorCURIE],
)
slots.import_as = Slot(
uri=LINKML.import_as,
name="import_as",
curie=LINKML.curie("import_as"),
model_uri=LINKML.import_as,
domain=ImportExpression,
range=Optional[Union[str, NCName]],
)
slots.import_map = Slot(
uri=LINKML.import_map,
name="import_map",
curie=LINKML.curie("import_map"),
model_uri=LINKML.import_map,
domain=ImportExpression,
range=Optional[Union[dict[Union[str, SettingSettingKey], Union[dict, "Setting"]], list[Union[dict, "Setting"]]]],
)
slots.local_name_source = Slot(
uri=LINKML.local_name_source,
name="local_name_source",
curie=LINKML.curie("local_name_source"),
model_uri=LINKML.local_name_source,
domain=LocalName,
range=Union[str, LocalNameLocalNameSource],
)
slots.local_name_value = Slot(
uri=SKOS.altLabel,
name="local_name_value",
curie=SKOS.curie("altLabel"),
model_uri=LINKML.local_name_value,
domain=LocalName,
range=str,
)
slots.local_names = Slot(
uri=LINKML.local_names,
name="local_names",
curie=LINKML.curie("local_names"),
model_uri=LINKML.local_names,
domain=Element,
range=Optional[
Union[dict[Union[str, LocalNameLocalNameSource], Union[dict, "LocalName"]], list[Union[dict, "LocalName"]]]
],
)
slots.slot_group = Slot(
uri=SH.group,
name="slot_group",
curie=SH.curie("group"),
model_uri=LINKML.slot_group,
domain=SlotDefinition,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.is_grouping_slot = Slot(
uri=LINKML.is_grouping_slot,
name="is_grouping_slot",
curie=LINKML.curie("is_grouping_slot"),
model_uri=LINKML.is_grouping_slot,
domain=SlotDefinition,
range=Optional[Union[bool, Bool]],
)
slots.followed_by = Slot(
uri=LINKML.followed_by,
name="followed_by",
curie=LINKML.curie("followed_by"),
model_uri=LINKML.followed_by,
domain=None,
range=Optional[Union[dict, Expression]],
)
slots.reversed = Slot(
uri=LINKML.reversed,
name="reversed",
curie=LINKML.curie("reversed"),
model_uri=LINKML.reversed,
domain=None,
range=Optional[Union[bool, Bool]],
)
slots.traverse = Slot(
uri=LINKML.traverse,
name="traverse",
curie=LINKML.curie("traverse"),
model_uri=LINKML.traverse,
domain=None,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.path_rule = Slot(
uri=LINKML.path_rule,
name="path_rule",
curie=LINKML.curie("path_rule"),
model_uri=LINKML.path_rule,
domain=SlotDefinition,
range=Optional[Union[dict, PathExpression]],
)
slots.represents_relationship = Slot(
uri=LINKML.represents_relationship,
name="represents_relationship",
curie=LINKML.curie("represents_relationship"),
model_uri=LINKML.represents_relationship,
domain=ClassDefinition,
range=Optional[Union[bool, Bool]],
)
slots.relational_role = Slot(
uri=LINKML.relational_role,
name="relational_role",
curie=LINKML.curie("relational_role"),
model_uri=LINKML.relational_role,
domain=SlotDefinition,
range=Optional[Union[str, "RelationalRoleEnum"]],
)
slots.schema_definition_name = Slot(
uri=RDFS.label,
name="schema_definition_name",
curie=RDFS.curie("label"),
model_uri=LINKML.schema_definition_name,
domain=SchemaDefinition,
range=Union[str, SchemaDefinitionName],
)
slots.type_expression_any_of = Slot(
uri=LINKML.any_of,
name="type_expression_any_of",
curie=LINKML.curie("any_of"),
model_uri=LINKML.type_expression_any_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]],
)
slots.type_expression_all_of = Slot(
uri=LINKML.all_of,
name="type_expression_all_of",
curie=LINKML.curie("all_of"),
model_uri=LINKML.type_expression_all_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]],
)
slots.type_expression_exactly_one_of = Slot(
uri=LINKML.exactly_one_of,
name="type_expression_exactly_one_of",
curie=LINKML.curie("exactly_one_of"),
model_uri=LINKML.type_expression_exactly_one_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]],
)
slots.type_expression_none_of = Slot(
uri=LINKML.none_of,
name="type_expression_none_of",
curie=LINKML.curie("none_of"),
model_uri=LINKML.type_expression_none_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousTypeExpression"], list[Union[dict, "AnonymousTypeExpression"]]]],
)
slots.type_definition_union_of = Slot(
uri=LINKML.union_of,
name="type_definition_union_of",
curie=LINKML.curie("union_of"),
model_uri=LINKML.type_definition_union_of,
domain=TypeDefinition,
range=Optional[Union[Union[str, TypeDefinitionName], list[Union[str, TypeDefinitionName]]]],
)
slots.enum_binding_range = Slot(
uri=LINKML.range,
name="enum_binding_range",
curie=LINKML.curie("range"),
model_uri=LINKML.enum_binding_range,
domain=EnumBinding,
range=Optional[Union[str, EnumDefinitionName]],
)
slots.structured_alias_categories = Slot(
uri=DCTERMS.subject,
name="structured_alias_categories",
curie=DCTERMS.curie("subject"),
model_uri=LINKML.structured_alias_categories,
domain=StructuredAlias,
range=Optional[Union[Union[str, URIorCURIE], list[Union[str, URIorCURIE]]]],
)
slots.path_expression_followed_by = Slot(
uri=LINKML.followed_by,
name="path_expression_followed_by",
curie=LINKML.curie("followed_by"),
model_uri=LINKML.path_expression_followed_by,
domain=PathExpression,
range=Optional[Union[dict, "PathExpression"]],
)
slots.path_expression_any_of = Slot(
uri=LINKML.any_of,
name="path_expression_any_of",
curie=LINKML.curie("any_of"),
model_uri=LINKML.path_expression_any_of,
domain=PathExpression,
range=Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]],
)
slots.path_expression_exactly_one_of = Slot(
uri=LINKML.exactly_one_of,
name="path_expression_exactly_one_of",
curie=LINKML.curie("exactly_one_of"),
model_uri=LINKML.path_expression_exactly_one_of,
domain=PathExpression,
range=Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]],
)
slots.path_expression_none_of = Slot(
uri=LINKML.none_of,
name="path_expression_none_of",
curie=LINKML.curie("none_of"),
model_uri=LINKML.path_expression_none_of,
domain=PathExpression,
range=Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]],
)
slots.path_expression_all_of = Slot(
uri=LINKML.all_of,
name="path_expression_all_of",
curie=LINKML.curie("all_of"),
model_uri=LINKML.path_expression_all_of,
domain=PathExpression,
range=Optional[Union[Union[dict, "PathExpression"], list[Union[dict, "PathExpression"]]]],
)
slots.slot_expression_any_of = Slot(
uri=LINKML.any_of,
name="slot_expression_any_of",
curie=LINKML.curie("any_of"),
model_uri=LINKML.slot_expression_any_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]],
)
slots.slot_expression_all_of = Slot(
uri=LINKML.all_of,
name="slot_expression_all_of",
curie=LINKML.curie("all_of"),
model_uri=LINKML.slot_expression_all_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]],
)
slots.slot_expression_exactly_one_of = Slot(
uri=LINKML.exactly_one_of,
name="slot_expression_exactly_one_of",
curie=LINKML.curie("exactly_one_of"),
model_uri=LINKML.slot_expression_exactly_one_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]],
)
slots.slot_expression_none_of = Slot(
uri=LINKML.none_of,
name="slot_expression_none_of",
curie=LINKML.curie("none_of"),
model_uri=LINKML.slot_expression_none_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousSlotExpression"], list[Union[dict, "AnonymousSlotExpression"]]]],
)
slots.slot_definition_is_a = Slot(
uri=LINKML.is_a,
name="slot_definition_is_a",
curie=LINKML.curie("is_a"),
model_uri=LINKML.slot_definition_is_a,
domain=SlotDefinition,
range=Optional[Union[str, SlotDefinitionName]],
)
slots.slot_definition_mixins = Slot(
uri=LINKML.mixins,
name="slot_definition_mixins",
curie=LINKML.curie("mixins"),
model_uri=LINKML.slot_definition_mixins,
domain=SlotDefinition,
range=Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]],
)
slots.slot_definition_apply_to = Slot(
uri=LINKML.apply_to,
name="slot_definition_apply_to",
curie=LINKML.curie("apply_to"),
model_uri=LINKML.slot_definition_apply_to,
domain=SlotDefinition,
range=Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]],
)
slots.slot_definition_disjoint_with = Slot(
uri=LINKML.disjoint_with,
name="slot_definition_disjoint_with",
curie=LINKML.curie("disjoint_with"),
model_uri=LINKML.slot_definition_disjoint_with,
domain=SlotDefinition,
range=Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]],
)
slots.slot_definition_union_of = Slot(
uri=LINKML.union_of,
name="slot_definition_union_of",
curie=LINKML.curie("union_of"),
model_uri=LINKML.slot_definition_union_of,
domain=SlotDefinition,
range=Optional[Union[Union[str, SlotDefinitionName], list[Union[str, SlotDefinitionName]]]],
)
slots.class_expression_any_of = Slot(
uri=LINKML.any_of,
name="class_expression_any_of",
curie=LINKML.curie("any_of"),
model_uri=LINKML.class_expression_any_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]],
)
slots.class_expression_all_of = Slot(
uri=LINKML.all_of,
name="class_expression_all_of",
curie=LINKML.curie("all_of"),
model_uri=LINKML.class_expression_all_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]],
)
slots.class_expression_exactly_one_of = Slot(
uri=LINKML.exactly_one_of,
name="class_expression_exactly_one_of",
curie=LINKML.curie("exactly_one_of"),
model_uri=LINKML.class_expression_exactly_one_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]],
)
slots.class_expression_none_of = Slot(
uri=LINKML.none_of,
name="class_expression_none_of",
curie=LINKML.curie("none_of"),
model_uri=LINKML.class_expression_none_of,
domain=None,
range=Optional[Union[Union[dict, "AnonymousClassExpression"], list[Union[dict, "AnonymousClassExpression"]]]],
)
slots.class_definition_is_a = Slot(
uri=LINKML.is_a,
name="class_definition_is_a",
curie=LINKML.curie("is_a"),
model_uri=LINKML.class_definition_is_a,
domain=ClassDefinition,
range=Optional[Union[str, ClassDefinitionName]],
)
slots.class_definition_mixins = Slot(
uri=LINKML.mixins,
name="class_definition_mixins",
curie=LINKML.curie("mixins"),
model_uri=LINKML.class_definition_mixins,
domain=ClassDefinition,
range=Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]],
)
slots.class_definition_apply_to = Slot(
uri=LINKML.apply_to,
name="class_definition_apply_to",
curie=LINKML.curie("apply_to"),
model_uri=LINKML.class_definition_apply_to,
domain=ClassDefinition,
range=Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]],
)
slots.class_definition_rules = Slot(
uri=SH.rule,
name="class_definition_rules",
curie=SH.curie("rule"),
model_uri=LINKML.class_definition_rules,
domain=ClassDefinition,
range=Optional[Union[Union[dict, "ClassRule"], list[Union[dict, "ClassRule"]]]],
)
slots.class_definition_disjoint_with = Slot(
uri=LINKML.disjoint_with,
name="class_definition_disjoint_with",
curie=LINKML.curie("disjoint_with"),
model_uri=LINKML.class_definition_disjoint_with,
domain=ClassDefinition,
range=Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]],
)
slots.class_definition_union_of = Slot(
uri=LINKML.union_of,
name="class_definition_union_of",
curie=LINKML.curie("union_of"),
model_uri=LINKML.class_definition_union_of,
domain=ClassDefinition,
range=Optional[Union[Union[str, ClassDefinitionName], list[Union[str, ClassDefinitionName]]]],
)
slots.permissible_value_is_a = Slot(
uri=LINKML.is_a,
name="permissible_value_is_a",
curie=LINKML.curie("is_a"),
model_uri=LINKML.permissible_value_is_a,
domain=PermissibleValue,
range=Optional[Union[str, PermissibleValueText]],
)
slots.permissible_value_mixins = Slot(
uri=LINKML.mixins,
name="permissible_value_mixins",
curie=LINKML.curie("mixins"),
model_uri=LINKML.permissible_value_mixins,
domain=PermissibleValue,
range=Optional[Union[Union[str, PermissibleValueText], list[Union[str, PermissibleValueText]]]],
)