def test_basics(self):
BFO = CurieNamespace('bfo', "http://purl.obolibrary.org/obo/BFO_")
self.assertEqual(URIRef("http://purl.obolibrary.org/obo/BFO_test"),
BFO.test)
self.assertEqual("http://purl.obolibrary.org/obo/BFO_", BFO)
self.assertEqual("bfo:test", BFO.curie('test'))
self.assertEqual("bfo:", BFO.curie())
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",
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,
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,
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,
@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]])
"""
_inherited_slots: ClassVar[List[str]] = []
class_class_uri: ClassVar[URIRef] = TCCM.ExternalValueSetDefinition
class_class_curie: ClassVar[str] = "tccm:ExternalValueSetDefinition"
class_name: ClassVar[str] = "ExternalValueSetDefinition"
class_model_uri: ClassVar[URIRef] = TCCM.ExternalValueSetDefinition
value: str = None
# Slots
class slots:
pass
slots.valueSetDefinition__definitionOf = Slot(uri=TCCM.definitionOf, name="valueSetDefinition__definitionOf", curie=TCCM.curie('definitionOf'),
model_uri=TCCM.valueSetDefinition__definitionOf, domain=None, range=Optional[Union[dict, ValueSetReference]])
slots.valueSetDefinition__versionTag = Slot(uri=TCCM.versionTag, name="valueSetDefinition__versionTag", curie=TCCM.curie('versionTag'),
model_uri=TCCM.valueSetDefinition__versionTag, domain=None, range=Dict[Union[str, VersionTagReferenceName], Union[dict, VersionTagReference]])
slots.valueSetDefinition__entry = Slot(uri=TCCM.entry, name="valueSetDefinition__entry", curie=TCCM.curie('entry'),
model_uri=TCCM.valueSetDefinition__entry, domain=None, range=List[Union[dict, ValueSetDefinitionEntry]])
slots.valueSetDefinitionEntry__include = Slot(uri=TCCM.include, name="valueSetDefinitionEntry__include", curie=TCCM.curie('include'),
model_uri=TCCM.valueSetDefinitionEntry__include, domain=None, range=List[Union[dict, FormalDefinition]])
slots.valueSetDefinitionEntry__exclude = Slot(uri=TCCM.exclude, name="valueSetDefinitionEntry__exclude", curie=TCCM.curie('exclude'),
model_uri=TCCM.valueSetDefinitionEntry__exclude, domain=None, range=List[Union[dict, FormalDefinition]])
slots.valueSetDefinitionEntry__intersect = Slot(uri=TCCM.intersect, name="valueSetDefinitionEntry__intersect", curie=TCCM.curie('intersect'),
slot_uri: Optional[str] = None
slot_curie: Optional[str] = None
class_uri: Optional[str] = None
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, range=Optional[str])
slots.s2p = Slot(uri=TEST.s2p, name="s2p", curie=TEST.curie('s2p'),
model_uri=TEST.s2p, domain=None, range=Optional[str])
slots.slot_uri = Slot(uri=TEST.slot_uri, name="slot_uri", curie=TEST.curie('slot_uri'),
model_uri=TEST.slot_uri, domain=None, range=Optional[str])
slots.slot_curie = Slot(uri=TEST.slot_curie, name="slot_curie", curie=TEST.curie('slot_curie'),
self.value = str(self.value)
super().__post_init__(**kwargs)
# 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)
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]]]])
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,
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'),
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: List[Union[str, IriType]] = empty_list()
def __post_init__(self, **kwargs: Dict[str, Any]):
if not isinstance(self.category, list) or 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] if isinstance(self.category, str
) else 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=List[Union[str, IriType]])
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'),
@dataclass
class C1(YAMLRoot):
_inherited_slots: ClassVar[List[str]] = []
class_class_uri: ClassVar[URIRef] = TEST.C1
class_class_curie: ClassVar[str] = "test:C1"
class_name: ClassVar[str] = "c1"
class_model_uri: ClassVar[URIRef] = TEST.C1
s1: Optional[str] = SKOS.label
s2: Optional[str] = SKOS.definition
# 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.s2 = Slot(uri=TEST.s2,
name="s2",
curie=TEST.curie('s2'),
model_uri=TEST.s2,
domain=None,
range=Optional[str])
@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]]])
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"])
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)
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,
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,
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,
self.object = ObjectRange1Id(self.object)
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)
# Enumerations
# 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, range=Union[str, NamedThingId])
slots.object = Slot(uri=DEFAULT_.object, name="object", curie=DEFAULT_.curie('object'),
model_uri=DEFAULT_.object, domain=None, range=Union[str, NamedThingId])
slots.sex_qualifier = Slot(uri=DEFAULT_.sex_qualifier, name="sex qualifier", curie=DEFAULT_.curie('sex_qualifier'),
model_uri=DEFAULT_.sex_qualifier, domain=None, range=Optional[Union[str, NamedThingId]])
slots.mixin_owner_subject = Slot(uri=DEFAULT_.subject, name="mixin_owner_subject", curie=DEFAULT_.curie('subject'),
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,
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'),
slot_type=Extension,
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'),
XSD = CurieNamespace('xsd', 'http://www.w3.org/2001/XMLSchema#')
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,
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])
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]])
