class_name: ClassVar[str] = "test class" class_model_uri: ClassVar[URIRef] = URIRef( "https://microbiomedata/schema/TestClass") test_attribute_1: Optional[str] = None test_attribute_2: Optional[str] = None # Slots class slots: pass slots.attribute = Slot(uri=DEFAULT_.attribute, name="attribute", curie=DEFAULT_.curie('attribute'), model_uri=DEFAULT_.attribute, domain=NamedThing, range=Optional[str]) slots.test_attribute_1 = Slot(uri=DEFAULT_.test_attribute_1, name="test attribute 1", curie=DEFAULT_.curie('test_attribute_1'), model_uri=DEFAULT_.test_attribute_1, domain=NamedThing, range=Optional[str]) slots.test_attribute_2 = Slot(uri=DEFAULT_.test_attribute_2, name="test attribute 2", curie=DEFAULT_.curie('test_attribute_2'), model_uri=DEFAULT_.test_attribute_2, domain=None,
def __post_init__(self, **kwargs: Dict[str, Any]): if self.header is not None and not isinstance(self.header, ResolvedValueSetHeader): self.header = ResolvedValueSetHeader(**self.header) super().__post_init__(**kwargs) # Slots class slots: pass slots.resolvedValueSetHeader__resolutionOf = Slot( uri=TCCM.resolutionOf, name="resolvedValueSetHeader__resolutionOf", curie=TCCM.curie('resolutionOf'), model_uri=TCCM.resolvedValueSetHeader__resolutionOf, domain=None, range=Union[dict, ValueSetDefinitionReference]) slots.resolvedValueSetHeader__resolvedUsingCodeSystem = Slot( uri=TCCM.resolvedUsingCodeSystem, name="resolvedValueSetHeader__resolvedUsingCodeSystem", curie=TCCM.curie('resolvedUsingCodeSystem'), model_uri=TCCM.resolvedValueSetHeader__resolvedUsingCodeSystem, domain=None, range=Dict[Union[str, CodeSystemVersionReferenceName], Union[dict, CodeSystemVersionReference]]) slots.resolvedValueSetHeader__includesResolvedValueSet = Slot( uri=TCCM.includesResolvedValueSet,
if self.sex_qualifier is not None and not isinstance( self.sex_qualifier, NamedThingId): self.sex_qualifier = NamedThingId(self.sex_qualifier) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=NamedThing, range=Union[str, NamedThingId]) slots.name = Slot(uri=DEFAULT_.name, name="name", curie=DEFAULT_.curie('name'), model_uri=DEFAULT_.name, domain=NamedThing, range=str) slots.subject = Slot(uri=DEFAULT_.subject, name="subject", curie=DEFAULT_.curie('subject'), model_uri=DEFAULT_.subject, domain=None,
@dataclass class Course(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = SAMP.Course class_class_curie: ClassVar[str] = "samp:Course" class_name: ClassVar[str] = "course" class_model_uri: ClassVar[URIRef] = SAMP.Course name: Optional[str] = None # Slots class slots: pass slots.name = Slot(uri=SAMP.name, name="name", curie=SAMP.curie('name'), model_uri=SAMP.name, domain=None, range=Optional[str]) slots.courses = Slot(uri=SAMP.courses, name="courses", curie=SAMP.curie('courses'), model_uri=SAMP.courses, domain=None, range=Optional[Union[dict, Course]])
class_curie: Optional[str] = None bnode: Optional[str] = bnode() txt: Optional[str] = "penguins\"doves" int: Optional[str] = -1403 dfltrange: Optional[str] = None dfltns: Optional[str] = None # Slots class slots: pass slots.s1 = Slot(uri=TEST.s1, name="s1", curie=TEST.curie('s1'), model_uri=TEST.s1, domain=None, range=Optional[str]) slots.s1p = Slot(uri=TEST.s1p, name="s1p", curie=TEST.curie('s1p'), model_uri=TEST.s1p, domain=None, range=Optional[str]) slots.s2 = Slot(uri=TEST.s2, name="s2", curie=TEST.curie('s2'), model_uri=TEST.s2, domain=None,
self.complete = CompleteDirectory(self.complete) super().__post_init__(**kwargs) # Enumerations class CompleteDirectory(EnumDefinitionImpl): COMPLETE = PermissibleValue( text="COMPLETE", description="The Directory contains all of the qualifying entries") PARTIAL = PermissibleValue( text="PARTIAL", description= "The directory contains only a partial listing of the qualifying entries." ) _defn = EnumDefinition(name="CompleteDirectory", ) # Slots class slots: pass slots.directory__complete = Slot(uri=TCCM.complete, name="directory__complete", curie=TCCM.curie('complete'), model_uri=TCCM.directory__complete, domain=None, range=Union[str, "CompleteDirectory"])
self.id = ManagerId(self.id) for k, v in self.has_employees.items(): if not isinstance(v, Employee): self.has_employees[k] = Employee(id=k, **({} if v is None else v)) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=None, range=URIRef) slots.name = Slot(uri=DEFAULT_.name, name="name", curie=DEFAULT_.curie('name'), model_uri=DEFAULT_.name, domain=None, range=Optional[str]) slots.aliases = Slot(uri=DEFAULT_.aliases, name="aliases", curie=DEFAULT_.curie('aliases'), model_uri=DEFAULT_.aliases, domain=None,
name: Optional[str] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, OntologyClassId): self.id = OntologyClassId(self.id) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=NMDC.id, name="id", curie=NMDC.curie('id'), model_uri=NMDC.id, domain=None, range=URIRef) slots.name = Slot(uri=NMDC.name, name="name", curie=NMDC.curie('name'), model_uri=NMDC.name, domain=None, range=Optional[str]) slots.description = Slot(uri=DCTERMS.description, name="description", curie=DCTERMS.curie('description'), model_uri=NMDC.description, domain=None, range=Optional[str]) slots.has_characteristic = Slot(uri=NMDC.has_characteristic, name="has characteristic", curie=NMDC.curie('has_characteristic'), model_uri=NMDC.has_characteristic, domain=Annotation, range=Optional[Union[ElementIdentifier, CharacteristicId]]) slots.instance_of = Slot(uri=NMDC.instance_of, name="instance of", curie=NMDC.curie('instance_of'), model_uri=NMDC.instance_of, domain=None, range=Optional[Union[ElementIdentifier, OntologyClassId]]) slots.has_raw_value = Slot(uri=NMDC.has_raw_value, name="has raw value", curie=NMDC.curie('has_raw_value'), model_uri=NMDC.has_raw_value, domain=Annotation, range=str)
self.system = [] if not isinstance(self.system, (list)): self.system = [self.system] self._normalize_inlined_slot(slot_name="system", slot_type=ConceptSystem, key_name="namespace", inlined_as_list=True, keyed=True) super().__post_init__(**kwargs) # Enumerations # Slots class slots: pass slots.code = Slot(uri=SKOS.notation, name="code", curie=SKOS.curie('notation'), model_uri=TERMCI.code, domain=None, range=str) slots.designation = Slot(uri=SKOS.prefLabel, name="designation", curie=SKOS.curie('prefLabel'), model_uri=TERMCI.designation, domain=None, range=Optional[str]) slots.definition = Slot(uri=SKOS.definition, name="definition", curie=SKOS.curie('definition'), model_uri=TERMCI.definition, domain=None, range=Optional[str]) slots.reference = Slot(uri=SKOS.seeAlso, name="reference", curie=SKOS.curie('seeAlso'), model_uri=TERMCI.reference, domain=None, range=Optional[Union[Union[str, URI], List[Union[str, URI]]]]) slots.defined_in = Slot(uri=SKOS.inScheme, name="defined_in", curie=SKOS.curie('inScheme'), model_uri=TERMCI.defined_in, domain=None, range=Union[str, ConceptSystemNamespace]) slots.narrower_than = Slot(uri=SKOS.broader, name="narrower_than", curie=SKOS.curie('broader'), model_uri=TERMCI.narrower_than, domain=None, range=Optional[Union[Union[str, ConceptReferenceUri], List[Union[str, ConceptReferenceUri]]]])
class_class_uri: ClassVar[URIRef] = URIRef("http://example.org/tests/timepoint/GeographicLocationAtTime") class_class_curie: ClassVar[str] = None class_name: ClassVar[str] = "geographic location at time" class_model_uri: ClassVar[URIRef] = URIRef("http://example.org/tests/timepoint/GeographicLocationAtTime") k: Union[str, GeographicLocationAtTimeK] = None timepoint: Optional[Union[str, TimeType]] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.k is None: raise ValueError("k must be supplied") if not isinstance(self.k, GeographicLocationAtTimeK): self.k = GeographicLocationAtTimeK(self.k) if self.timepoint is not None and not isinstance(self.timepoint, TimeType): self.timepoint = TimeType(self.timepoint) super().__post_init__(**kwargs) # Slots class slots: pass slots.k = Slot(uri=DEFAULT_.k, name="k", curie=DEFAULT_.curie('k'), model_uri=DEFAULT_.k, domain=GeographicLocation, range=Union[str, GeographicLocationK]) slots.timepoint = Slot(uri=DEFAULT_.timepoint, name="timepoint", curie=DEFAULT_.curie('timepoint'), model_uri=DEFAULT_.timepoint, domain=GeographicLocationAtTime, range=Optional[Union[str, TimeType]])
if self.officialActivationDate is not None and not isinstance( self.officialActivationDate, XSDDateTime): self.officialActivationDate = XSDDateTime( self.officialActivationDate) super().__post_init__(**kwargs) # Slots class slots: pass slots.resourceDescription__describedResourceType = Slot( uri=TCCM.describedResourceType, name="resourceDescription__describedResourceType", curie=TCCM.curie('describedResourceType'), model_uri=TCCM.resourceDescription__describedResourceType, domain=None, range=Optional[str]) slots.resourceDescription__resourceSynopsis = Slot( uri=TCCM.resourceSynopsis, name="resourceDescription__resourceSynopsis", curie=TCCM.curie('resourceSynopsis'), model_uri=TCCM.resourceDescription__resourceSynopsis, domain=None, range=Optional[str]) slots.resourceDescription__resourceID = Slot( uri=TCCM.id, name="resourceDescription__resourceID",
for v in ([self.filterComponent] if isinstance(self.filterComponent, str) else self.filterComponent)] if self.matchAlgorithm is None: raise ValueError(f"matchAlgorithm must be supplied") if not isinstance(self.matchAlgorithm, MatchAlgorithmReference): self.matchAlgorithm = MatchAlgorithmReference(self.matchAlgorithm) super().__post_init__(**kwargs) # Slots class slots: pass slots.filter__component = Slot(uri=TCCM.component, name="filter__component", curie=TCCM.curie('component'), model_uri=TCCM.filter__component, domain=None, range=List[Union[dict, FilterComponent]]) slots.filter__description = Slot(uri=TCCM.description, name="filter__description", curie=TCCM.curie('description'), model_uri=TCCM.filter__description, domain=None, range=Optional[str]) slots.filterComponent__filterComponent = Slot( uri=TCCM.filterComponent, name="filterComponent__filterComponent", curie=TCCM.curie('filterComponent'), model_uri=TCCM.filterComponent__filterComponent,
@dataclass class C3(C1): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = EX.C3 class_class_curie: ClassVar[str] = "ex:C3" class_name: ClassVar[str] = "c3" class_model_uri: ClassVar[URIRef] = EX.C3 s2: Union[str, C3S2] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.s2 is None: raise ValueError(f"s2 must be supplied") if not isinstance(self.s2, C3S2): self.s2 = C3S2(self.s2) super().__post_init__(**kwargs) # Slots class slots: pass slots.s1 = Slot(uri=EX.s1, name="s1", curie=EX.curie('s1'), model_uri=EX.s1, domain=C1, range=Optional[str]) slots.s2 = Slot(uri=EX.s2, name="s2", curie=EX.curie('s2'), model_uri=EX.s2, domain=C1, range=Union[str, C1S2])
@dataclass class C260a(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = URIRef( "http://example.org/tests/issue_260a/C260a") class_class_curie: ClassVar[str] = None class_name: ClassVar[str] = "C260a" class_model_uri: ClassVar[URIRef] = URIRef( "http://example.org/tests/issue_260a/C260a") id: Optional[str] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is not None and not isinstance(self.id, str): self.id = str(self.id) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=None, range=Optional[str])
node_property: Optional[Union[URIorCURIE, IdentifierType]] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, SequenceVariantId): self.id = SequenceVariantId(self.id) if self.node_property is not None and not isinstance(self.node_property, IdentifierType): self.node_property = IdentifierType(self.node_property) super().__post_init__(**kwargs) # Slots class slots: pass slots.node_property = Slot(uri=DEFAULT_.node_property, name="node property", curie=DEFAULT_.curie('node_property'), model_uri=DEFAULT_.node_property, domain=NamedThing, range=Optional[Union[URIorCURIE, IdentifierType]]) slots.not_overridden = Slot(uri=DEFAULT_.not_overridden, name="not overridden", curie=DEFAULT_.curie('not_overridden'), model_uri=DEFAULT_.not_overridden, domain=NamedThing, range=Optional[Union[URIorCURIE, IdentifierType]]) slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=NamedThing, range=Union[URIorCURIE, NamedThingId]) slots.sequence_variant_id = Slot(uri=DEFAULT_.id, name="sequence variant_id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.sequence_variant_id, domain=SequenceVariant, range=Union[URIorCURIE, SequenceVariantId]) slots.sequence_variant_node_property = Slot(uri=DEFAULT_.node_property, name="sequence variant_node property", curie=DEFAULT_.curie('node_property'), model_uri=DEFAULT_.sequence_variant_node_property, domain=SequenceVariant, range=Optional[Union[URIorCURIE, IdentifierType]])
a tag/value pair with the semantics of OWL Annotation """ _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = META.Annotation class_class_curie: ClassVar[str] = "meta:Annotation" class_name: ClassVar[str] = "annotation" class_model_uri: ClassVar[URIRef] = META.Annotation tag: Union[str, URIorCURIE] = None value: str = None annotations: Optional[Union[Union[dict, "Annotation"], List[Union[dict, "Annotation"]]]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): if self.annotations is None: self.annotations = [] if not isinstance(self.annotations, list): self.annotations = [self.annotations] self._normalize_inlined_slot(slot_name="annotations", slot_type=Annotation, key_name="tag", inlined_as_list=True, keyed=False) super().__post_init__(**kwargs) # Slots class slots: pass slots.annotations = Slot(uri=META.annotations, name="annotations", curie=META.curie('annotations'), model_uri=META.annotations, domain=None, range=Optional[Union[Union[dict, Annotation], List[Union[dict, Annotation]]]])
@dataclass class NamedThing(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = URIRef("https://example.com/test44/NamedThing") class_class_curie: ClassVar[str] = None class_name: ClassVar[str] = "named thing" class_model_uri: ClassVar[URIRef] = URIRef("https://example.com/test44/NamedThing") category: Union[Union[str, IriType], List[Union[str, IriType]]] = None def __post_init__(self, **kwargs: Dict[str, Any]): if self.category is None: raise ValueError("category must be supplied") elif not isinstance(self.category, list): self.category = [self.category] elif len(self.category) == 0: raise ValueError(f"category must be a non-empty list") self.category = [v if isinstance(v, IriType) else IriType(v) for v in self.category] super().__post_init__(**kwargs) # Slots class slots: pass slots.category = Slot(uri=RDFS.subClassOf, name="category", curie=RDFS.curie('subClassOf'), model_uri=DEFAULT_.category, domain=NamedThing, range=Union[Union[str, IriType], List[Union[str, IriType]]])
# Enumerations # Slots class slots: pass slots.container__entry = Slot(uri=SCT.entry, name="container__entry", curie=SCT.curie('entry'), model_uri=SCT.container__entry, domain=None, range=Optional[Union[Dict[Union[str, ContaineeId], Union[dict, Containee]], List[Union[dict, Containee]]]]) slots.containee__id = Slot(uri=SCT.id, name="containee__id", curie=SCT.curie('id'), model_uri=SCT.containee__id, domain=None, range=URIRef) slots.containee__value = Slot(uri=SCT.value, name="containee__value",
self.id = EId(self.id) super().__post_init__(**kwargs) # Enumerations # Slots class slots: pass slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=None, range=URIRef) slots.has_a = Slot(uri=DEFAULT_.has_a, name="has a", curie=DEFAULT_.curie('has_a'), model_uri=DEFAULT_.has_a, domain=None, range=Optional[Union[str, AId]]) slots.has_b = Slot(uri=DEFAULT_.has_b, name="has b", curie=DEFAULT_.curie('has_b'), model_uri=DEFAULT_.has_b, domain=None,
value: Bool = None annotations: List[Union[dict, "Annotation"]] = empty_list() def __post_init__(self, **kwargs: Dict[str, Any]): self.annotations = [Annotation(*e) for e in self.annotations.items()] if isinstance(self.annotations, dict) \ else [v if isinstance(v, Annotation) else Annotation(**v) for v in ([self.annotations] if isinstance(self.annotations, str) else self.annotations)] if self.value is None: raise ValueError(f"value must be supplied") super().__post_init__(**kwargs) # Slots class slots: pass slots.annotations = Slot(uri=META.annotations, name="annotations", curie=META.curie('annotations'), model_uri=META.annotations, domain=None, range=List[Union[dict, Annotation]]) slots.annotation_extension_value = Slot( uri=META.value, name="annotation_extension_value", curie=META.curie('value'), model_uri=META.annotation_extension_value, domain=Annotation, range=Bool)
def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, C3Id): self.id = C3Id(self.id) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=None, range=URIRef) slots.s1 = Slot(uri=DEFAULT_.s1, name="s1", curie=DEFAULT_.curie('s1'), model_uri=DEFAULT_.s1, domain=C1, range=Optional[str]) slots.s2 = Slot(uri=DEFAULT_.s2, name="s2", curie=DEFAULT_.curie('s2'), model_uri=DEFAULT_.s2, domain=C2,
if self.hasNcName is not None and not isinstance( self.hasNcName, NCName): self.hasNcName = NCName(self.hasNcName) if self.id2 is not None and not isinstance(self.id2, NodeIdentifier): self.id2 = NodeIdentifier(self.id2) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=M.id, name="id", curie=M.curie('id'), model_uri=M.id, domain=None, range=URIRef) slots.hasCurie = Slot(uri=M.hasCurie, name="hasCurie", curie=M.curie('hasCurie'), model_uri=M.hasCurie, domain=None, range=Optional[Union[str, Curie]]) slots.hasURI = Slot(uri=M.hasURI, name="hasURI", curie=M.curie('hasURI'), model_uri=M.hasURI, domain=None,
class ImportedClass(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = URIRef( "https://microbiomedata/schema/mixs/ImportedClass") class_class_curie: ClassVar[str] = None class_name: ClassVar[str] = "imported class" class_model_uri: ClassVar[URIRef] = URIRef( "https://microbiomedata/schema/ImportedClass") # Slots class slots: pass slots.depth = Slot(uri=DEFAULT_['mixs/depth'], name="depth", curie=DEFAULT_.curie('mixs/depth'), model_uri=DEFAULT_.depth, domain=None, range=Optional[str]) slots.biosample_depth = Slot(uri=DEFAULT_.depth, name="biosample_depth", curie=DEFAULT_.curie('depth'), model_uri=DEFAULT_.biosample_depth, domain=Biosample, range=Optional[str])
class_model_uri: ClassVar[URIRef] = URIRef("http://example.com/TestClass3") id: Union[str, TestClass3Id] def __post_init__(self, **kwargs: Dict[str, Any]): if self.id is None: raise ValueError(f"id must be supplied") if not isinstance(self.id, TestClass3Id): self.id = TestClass3Id(self.id) super().__post_init__(**kwargs) # Slots class slots: pass slots.id = Slot(uri=DEFAULT_.id, name="id", curie=DEFAULT_.curie('id'), model_uri=DEFAULT_.id, domain=None, range=URIRef) slots.optional_mixin_slot = Slot(uri=DEFAULT_.optional_mixin_slot, name="optional_mixin_slot", curie=DEFAULT_.curie('optional_mixin_slot'), model_uri=DEFAULT_.optional_mixin_slot, domain=None, range=Optional[str]) slots.required_mixin_slot = Slot(uri=DEFAULT_.required_mixin_slot, name="required_mixin_slot", curie=DEFAULT_.curie('required_mixin_slot'), model_uri=DEFAULT_.required_mixin_slot, domain=None, range=str) slots.optional_domain_slot = Slot(uri=DEFAULT_.optional_domain_slot, name="optional_domain_slot", curie=DEFAULT_.curie('optional_domain_slot'), model_uri=DEFAULT_.optional_domain_slot, domain=TestClass3, range=Optional[str]) slots.required_domain_slot = Slot(uri=DEFAULT_.required_domain_slot, name="required_domain_slot", curie=DEFAULT_.curie('required_domain_slot'), model_uri=DEFAULT_.required_domain_slot, domain=TestClass3, range=str)
self.age = int(self.age) super().__post_init__(**kwargs) # Enumerations # Slots class slots: pass slots.id = Slot(uri=BIOLINK.id, name="id", curie=BIOLINK.curie('id'), model_uri=BIOLINK.id, domain=None, range=URIRef) slots.name = Slot(uri=BIOLINK.name, name="name", curie=BIOLINK.curie('name'), model_uri=BIOLINK.name, domain=None, range=str) slots.age = Slot(uri=BIOLINK.age, name="age", curie=BIOLINK.curie('age'), model_uri=BIOLINK.age, domain=None,
def __post_init__(self, **kwargs: Dict[str, Any]): if self.source is None: raise ValueError(f"source must be supplied") if not isinstance(self.source, AltDescriptionSource): self.source = AltDescriptionSource(self.source) if self.description is None: raise ValueError(f"description must be supplied") super().__post_init__(**kwargs) # Slots class slots: pass slots.name = Slot(uri=RDFS.label, name="name", curie=RDFS.curie('label'), model_uri=META.name, domain=Element, range=Union[str, ElementName], mappings = [SCHEMA.name]) slots.definition_uri = Slot(uri=META.definition_uri, name="definition_uri", curie=META.curie('definition_uri'), model_uri=META.definition_uri, domain=Element, range=Optional[Union[str, URIorCURIE]]) slots.id_prefixes = Slot(uri=META.id_prefixes, name="id_prefixes", curie=META.curie('id_prefixes'), model_uri=META.id_prefixes, domain=Element, range=List[Union[str, NCName]]) slots.description = Slot(uri=SKOS.definition, name="description", curie=SKOS.curie('definition'), model_uri=META.description, domain=Element, range=Optional[str]) slots.aliases = Slot(uri=SKOS.altLabel, name="aliases", curie=SKOS.curie('altLabel'), model_uri=META.aliases, domain=Element, range=List[str]) slots.deprecated = Slot(uri=META.deprecated, name="deprecated", curie=META.curie('deprecated'), model_uri=META.deprecated, domain=Element, range=Optional[str])
key_name="tag", inlined_as_list=True, keyed=False) super().__post_init__(**kwargs) # Slots class slots: pass slots.extensions = Slot(uri=META.extensions, name="extensions", curie=META.curie('extensions'), model_uri=META.extensions, domain=None, range=Optional[Union[Union[dict, Extension], List[Union[dict, Extension]]]]) slots.extension_tag = Slot(uri=META.tag, name="extension_tag", curie=META.curie('tag'), model_uri=META.extension_tag, domain=Extension, range=Union[str, URIorCURIE]) slots.extension_value = Slot(uri=META.value, name="extension_value", curie=META.curie('value'), model_uri=META.extension_value,
DEFAULT_ = META # Types # Class references # Slots class slots: pass slots.mappings = Slot(uri=SKOS.mappingRelation, name="mappings", curie=SKOS.curie('mappingRelation'), model_uri=META.mappings, domain=None, range=Optional[Union[Union[str, URIorCURIE], List[Union[str, URIorCURIE]]]]) slots.exact_mappings = Slot(uri=SKOS.exactMatch, name="exact mappings", curie=SKOS.curie('exactMatch'), model_uri=META.exact_mappings, domain=None, range=Optional[Union[Union[str, URIorCURIE], List[Union[str, URIorCURIE]]]]) slots.close_mappings = Slot(uri=SKOS.closeMatch, name="close mappings",
class C2(YAMLRoot): _inherited_slots: ClassVar[List[str]] = [] class_class_uri: ClassVar[URIRef] = URIRef( "https://issue_test/106/schema/C2") class_class_curie: ClassVar[str] = None class_name: ClassVar[str] = "c2" class_model_uri: ClassVar[URIRef] = URIRef( "https://issue_test/106/schema/C2") s1: Optional[str] = None # Slots class slots: pass slots.s1 = Slot(uri=DEFAULT_.s1, name="s1", curie=DEFAULT_.curie('s1'), model_uri=DEFAULT_.s1, domain=None, range=Optional[str]) slots.s2 = Slot(uri=DEFAULT_.s2, name="s2", curie=DEFAULT_.curie('s2'), model_uri=DEFAULT_.s2, domain=None, range=Optional[str])
region: Optional[str] = None biome: Optional[str] = None feature: Optional[str] = None id: Optional[str] = None name: Optional[str] = None well: Optional[str] = None env_pakcage: Optional[str] = None latitude: Optional[float] = None longitude: Optional[float] = None # Slots class slots: pass slots.age_max = Slot(uri=KBASE.age_max, name="age_max", curie=KBASE.curie('age_max'), model_uri=KBASE.age_max, domain=None, range=Optional[float]) slots.age_min = Slot(uri=KBASE.age_min, name="age_min", curie=KBASE.curie('age_min'), model_uri=KBASE.age_min, domain=None, range=Optional[float]) slots.aodc = Slot(uri=KBASE.aodc, name="aodc", curie=KBASE.curie('aodc'), model_uri=KBASE.aodc, domain=None, range=Optional[float]) slots.aquifer = Slot(uri=KBASE.aquifer, name="aquifer", curie=KBASE.curie('aquifer'), model_uri=KBASE.aquifer, domain=None, range=Optional[str]) slots.area_name = Slot(uri=KBASE.area_name, name="area_name", curie=KBASE.curie('area_name'), model_uri=KBASE.area_name, domain=None, range=Optional[str]) slots.average_water_level = Slot(uri=KBASE.average_water_level, name="average_water_level", curie=KBASE.curie('average_water_level'), model_uri=KBASE.average_water_level, domain=None, range=Optional[float])