kempersc/glam
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
glam/src/glam_extractor/models.py
kempersc 3a242370fc annotation standards added
2025-12-05 15:30:23 +01:00

3148 lines
155 KiB
Python
Raw Blame History

# Auto generated from heritage_custodian.yaml by pythongen.py version: 0.0.1
# Generation date: 2025-11-11T23:16:09
# Schema: heritage-custodian
#
# id: https://w3id.org/heritage/custodian
# description: A comprehensive LinkML schema for modeling heritage institutions (GLAM - Galleries, Libraries, Archives, Museums) worldwide. This schema integrates multiple standards including TOOI (Dutch organizational ontology), Schema.org, CPOC (Core Public Organization Vocabulary), ISIL (International Standard Identifier for Libraries), and domain-specific vocabularies (RiC-O, BIBFRAME, LIDO, CIDOC-CRM).
# license: https://creativecommons.org/publicdomain/zero/1.0/
import dataclasses
import re
from dataclasses import dataclass
from datetime import (
date,
datetime,
time
)
from typing import (
Any,
ClassVar,
Dict,
List,
Optional,
Union
)
from jsonasobj2 import (
JsonObj,
as_dict
)
from linkml_runtime.linkml_model.meta import (
EnumDefinition,
PermissibleValue,
PvFormulaOptions
)
from linkml_runtime.utils.curienamespace import CurieNamespace
from linkml_runtime.utils.enumerations import EnumDefinitionImpl
from linkml_runtime.utils.formatutils import (
camelcase,
sfx,
underscore
)
from linkml_runtime.utils.metamodelcore import (
bnode,
empty_dict,
empty_list
)
from linkml_runtime.utils.slot import Slot
from linkml_runtime.utils.yamlutils import (
YAMLRoot,
extended_float,
extended_int,
extended_str
)
from rdflib import (
Namespace,
URIRef
)
from linkml_runtime.linkml_model.types import Boolean, Date, Datetime, Float, Integer, String, Uri, Uriorcurie
from linkml_runtime.utils.metamodelcore import Bool, URI, URIorCURIE, XSDDate, XSDDateTime
metamodel_version = "1.7.0"
version = "0.2.2"
# Namespaces
ADMS = CurieNamespace('adms', 'http://www.w3.org/ns/adms#')
BF = CurieNamespace('bf', 'http://id.loc.gov/ontologies/bibframe/')
BIBO = CurieNamespace('bibo', 'http://purl.org/ontology/bibo/')
BIRO = CurieNamespace('biro', 'http://purl.org/spar/biro/')
CITO = CurieNamespace('cito', 'http://purl.org/spar/cito/')
CPOV = CurieNamespace('cpov', 'http://data.europa.eu/m8g/')
CRM = CurieNamespace('crm', 'http://www.cidoc-crm.org/cidoc-crm/')
DATACITE = CurieNamespace('datacite', 'http://purl.org/spar/datacite/')
DCTERMS = CurieNamespace('dcterms', 'http://purl.org/dc/terms/')
DOCO = CurieNamespace('doco', 'http://purl.org/spar/doco/')
EDM = CurieNamespace('edm', 'http://www.europeana.eu/schemas/edm/')
FABIO = CurieNamespace('fabio', 'http://purl.org/spar/fabio/')
FOAF = CurieNamespace('foaf', 'http://xmlns.com/foaf/0.1/')
FRBR = CurieNamespace('frbr', 'http://purl.org/vocab/frbr/core#')
GEONAMES = CurieNamespace('geonames', 'http://www.geonames.org/ontology#')
HERITAGE = CurieNamespace('heritage', 'https://w3id.org/heritage/custodian/')
LINKML = CurieNamespace('linkml', 'https://w3id.org/linkml/')
ORE = CurieNamespace('ore', 'http://www.openarchives.org/ore/terms/')
ORG = CurieNamespace('org', 'http://www.w3.org/ns/org#')
OWL = CurieNamespace('owl', 'http://www.w3.org/2002/07/owl#')
PRISM = CurieNamespace('prism', 'http://prismstandard.org/namespaces/basic/3.0/')
PRO = CurieNamespace('pro', 'http://purl.org/spar/pro/')
PROV = CurieNamespace('prov', 'http://www.w3.org/ns/prov#')
PSO = CurieNamespace('pso', 'http://purl.org/spar/pso/')
RDF = CurieNamespace('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
RDFS = CurieNamespace('rdfs', 'http://www.w3.org/2000/01/rdf-schema#')
RICO = CurieNamespace('rico', 'https://www.ica.org/standards/RiC/ontology#')
SCHEMA = CurieNamespace('schema', 'http://schema.org/')
SKOS = CurieNamespace('skos', 'http://www.w3.org/2004/02/skos/core#')
TOOI = CurieNamespace('tooi', 'http://standaarden.overheid.nl/tooi/def/')
TOOIONT = CurieNamespace('tooiont', 'https://identifier.overheid.nl/tooi/def/ont/')
VIAF = CurieNamespace('viaf', 'http://viaf.org/viaf/')
WIKIDATA = CurieNamespace('wikidata', 'http://www.wikidata.org/entity/')
XSD = CurieNamespace('xsd', 'http://www.w3.org/2001/XMLSchema#')
DEFAULT_ = HERITAGE
# Types
# Class references
class HeritageCustodianId(URIorCURIE):
pass
class OrganizationalUnitUnitId(URIorCURIE):
pass
class ChangeEventEventId(URIorCURIE):
pass
class DutchHeritageCustodianId(HeritageCustodianId):
pass
class ScholarlyWorkWorkId(URIorCURIE):
pass
class PublicationPublicationId(URIorCURIE):
pass
class JournalJournalId(URIorCURIE):
pass
class ConferenceConferenceId(URIorCURIE):
pass
class PersonPersonId(URIorCURIE):
pass
class OrganizationOrganizationId(URIorCURIE):
pass
class CitationCitationId(URIorCURIE):
pass
class DocumentSectionSectionId(URIorCURIE):
pass
class SchemaContactPoint(YAMLRoot):
"""
Local proxy for schema:ContactPoint. Represents contact information (phone, email, etc.) for an organization. Used
as mixin for ContactInfo.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = SCHEMA["ContactPoint"]
class_class_curie: ClassVar[str] = "schema:ContactPoint"
class_name: ClassVar[str] = "SchemaContactPoint"
class_model_uri: ClassVar[URIRef] = HERITAGE.SchemaContactPoint
@dataclass(repr=False)
class HeritageCustodian(YAMLRoot):
"""
A heritage custodian organization (GLAM institution) responsible for preserving, managing, and providing access to
cultural heritage collections. Integrates W3C Org Ontology, PROV-O provenance tracking, and TOOI temporal
patterns.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = ORG["Organization"]
class_class_curie: ClassVar[str] = "org:Organization"
class_name: ClassVar[str] = "HeritageCustodian"
class_model_uri: ClassVar[URIRef] = HERITAGE.HeritageCustodian
id: Union[str, HeritageCustodianId] = None
name: str = None
institution_type: Union[str, "InstitutionTypeEnum"] = None
provenance: Union[dict, "Provenance"] = None
record_id: Optional[str] = None
ghcid_uuid: Optional[str] = None
ghcid_uuid_sha256: Optional[str] = None
ghcid_numeric: Optional[int] = None
ghcid_current: Optional[str] = None
ghcid_original: Optional[str] = None
ghcid_history: Optional[Union[Union[dict, "GHCIDHistoryEntry"], list[Union[dict, "GHCIDHistoryEntry"]]]] = empty_list()
alternative_names: Optional[Union[str, list[str]]] = empty_list()
official_name: Optional[str] = None
sorting_name: Optional[str] = None
abbreviation: Optional[str] = None
organization_status: Optional[Union[str, "OrganizationStatusEnum"]] = None
description: Optional[str] = None
parent_organization: Optional[Union[str, HeritageCustodianId]] = None
parent_organization_name: Optional[str] = None
sub_organizations: Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]] = empty_list()
founded_date: Optional[Union[str, XSDDate]] = None
closed_date: Optional[Union[str, XSDDate]] = None
prov_generated_at: Optional[Union[str, XSDDateTime]] = None
prov_invalidated_at: Optional[Union[str, XSDDateTime]] = None
change_history: Optional[Union[dict[Union[str, ChangeEventEventId], Union[dict, "ChangeEvent"]], list[Union[dict, "ChangeEvent"]]]] = empty_dict()
homepage: Optional[Union[str, URI]] = None
contact_info: Optional[Union[dict, "ContactInfo"]] = None
locations: Optional[Union[Union[dict, "Location"], list[Union[dict, "Location"]]]] = empty_list()
identifiers: Optional[Union[Union[dict, "Identifier"], list[Union[dict, "Identifier"]]]] = empty_list()
chamber_of_commerce_number: Optional[str] = None
municipality_identifier: Optional[str] = None
collections: Optional[Union[Union[dict, "Collection"], list[Union[dict, "Collection"]]]] = empty_list()
digital_platforms: Optional[Union[Union[dict, "DigitalPlatform"], list[Union[dict, "DigitalPlatform"]]]] = empty_list()
metadata_standards: Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]] = empty_list()
partnerships: Optional[Union[Union[dict, "Partnership"], list[Union[dict, "Partnership"]]]] = empty_list()
publications: Optional[Union[dict[Union[str, PublicationPublicationId], Union[dict, "Publication"]], list[Union[dict, "Publication"]]]] = empty_dict()
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.id):
self.MissingRequiredField("id")
if not isinstance(self.id, HeritageCustodianId):
self.id = HeritageCustodianId(self.id)
if self._is_empty(self.name):
self.MissingRequiredField("name")
if not isinstance(self.name, str):
self.name = str(self.name)
if self._is_empty(self.institution_type):
self.MissingRequiredField("institution_type")
if not isinstance(self.institution_type, InstitutionTypeEnum):
self.institution_type = InstitutionTypeEnum(self.institution_type)
if self._is_empty(self.provenance):
self.MissingRequiredField("provenance")
if not isinstance(self.provenance, Provenance):
self.provenance = Provenance(**as_dict(self.provenance))
if self.record_id is not None and not isinstance(self.record_id, str):
self.record_id = str(self.record_id)
if self.ghcid_uuid is not None and not isinstance(self.ghcid_uuid, str):
self.ghcid_uuid = str(self.ghcid_uuid)
if self.ghcid_uuid_sha256 is not None and not isinstance(self.ghcid_uuid_sha256, str):
self.ghcid_uuid_sha256 = str(self.ghcid_uuid_sha256)
if self.ghcid_numeric is not None and not isinstance(self.ghcid_numeric, int):
self.ghcid_numeric = int(self.ghcid_numeric)
if self.ghcid_current is not None and not isinstance(self.ghcid_current, str):
self.ghcid_current = str(self.ghcid_current)
if self.ghcid_original is not None and not isinstance(self.ghcid_original, str):
self.ghcid_original = str(self.ghcid_original)
if not isinstance(self.ghcid_history, list):
self.ghcid_history = [self.ghcid_history] if self.ghcid_history is not None else []
self.ghcid_history = [v if isinstance(v, GHCIDHistoryEntry) else GHCIDHistoryEntry(**as_dict(v)) for v in self.ghcid_history]
if not isinstance(self.alternative_names, list):
self.alternative_names = [self.alternative_names] if self.alternative_names is not None else []
self.alternative_names = [v if isinstance(v, str) else str(v) for v in self.alternative_names]
if self.official_name is not None and not isinstance(self.official_name, str):
self.official_name = str(self.official_name)
if self.sorting_name is not None and not isinstance(self.sorting_name, str):
self.sorting_name = str(self.sorting_name)
if self.abbreviation is not None and not isinstance(self.abbreviation, str):
self.abbreviation = str(self.abbreviation)
if self.organization_status is not None and not isinstance(self.organization_status, OrganizationStatusEnum):
self.organization_status = OrganizationStatusEnum(self.organization_status)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
if self.parent_organization is not None and not isinstance(self.parent_organization, HeritageCustodianId):
self.parent_organization = HeritageCustodianId(self.parent_organization)
if self.parent_organization_name is not None and not isinstance(self.parent_organization_name, str):
self.parent_organization_name = str(self.parent_organization_name)
if not isinstance(self.sub_organizations, list):
self.sub_organizations = [self.sub_organizations] if self.sub_organizations is not None else []
self.sub_organizations = [v if isinstance(v, HeritageCustodianId) else HeritageCustodianId(v) for v in self.sub_organizations]
if self.founded_date is not None and not isinstance(self.founded_date, XSDDate):
self.founded_date = XSDDate(self.founded_date)
if self.closed_date is not None and not isinstance(self.closed_date, XSDDate):
self.closed_date = XSDDate(self.closed_date)
if self.prov_generated_at is not None and not isinstance(self.prov_generated_at, XSDDateTime):
self.prov_generated_at = XSDDateTime(self.prov_generated_at)
if self.prov_invalidated_at is not None and not isinstance(self.prov_invalidated_at, XSDDateTime):
self.prov_invalidated_at = XSDDateTime(self.prov_invalidated_at)
self._normalize_inlined_as_list(slot_name="change_history", slot_type=ChangeEvent, key_name="event_id", keyed=True)
if self.homepage is not None and not isinstance(self.homepage, URI):
self.homepage = URI(self.homepage)
if self.contact_info is not None and not isinstance(self.contact_info, ContactInfo):
self.contact_info = ContactInfo(**as_dict(self.contact_info))
if not isinstance(self.locations, list):
self.locations = [self.locations] if self.locations is not None else []
self.locations = [v if isinstance(v, Location) else Location(**as_dict(v)) for v in self.locations]
if not isinstance(self.identifiers, list):
self.identifiers = [self.identifiers] if self.identifiers is not None else []
self.identifiers = [v if isinstance(v, Identifier) else Identifier(**as_dict(v)) for v in self.identifiers]
if self.chamber_of_commerce_number is not None and not isinstance(self.chamber_of_commerce_number, str):
self.chamber_of_commerce_number = str(self.chamber_of_commerce_number)
if self.municipality_identifier is not None and not isinstance(self.municipality_identifier, str):
self.municipality_identifier = str(self.municipality_identifier)
if not isinstance(self.collections, list):
self.collections = [self.collections] if self.collections is not None else []
self.collections = [v if isinstance(v, Collection) else Collection(**as_dict(v)) for v in self.collections]
if not isinstance(self.digital_platforms, list):
self.digital_platforms = [self.digital_platforms] if self.digital_platforms is not None else []
self.digital_platforms = [v if isinstance(v, DigitalPlatform) else DigitalPlatform(**as_dict(v)) for v in self.digital_platforms]
if not isinstance(self.metadata_standards, list):
self.metadata_standards = [self.metadata_standards] if self.metadata_standards is not None else []
self.metadata_standards = [v if isinstance(v, MetadataStandardEnum) else MetadataStandardEnum(v) for v in self.metadata_standards]
if not isinstance(self.partnerships, list):
self.partnerships = [self.partnerships] if self.partnerships is not None else []
self.partnerships = [v if isinstance(v, Partnership) else Partnership(**as_dict(v)) for v in self.partnerships]
self._normalize_inlined_as_list(slot_name="publications", slot_type=Publication, key_name="publication_id", keyed=True)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Location(YAMLRoot):
"""
Physical or virtual location associated with an organization
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = SCHEMA["Place"]
class_class_curie: ClassVar[str] = "schema:Place"
class_name: ClassVar[str] = "Location"
class_model_uri: ClassVar[URIRef] = HERITAGE.Location
location_type: Optional[str] = None
street_address: Optional[str] = None
city: Optional[str] = None
postal_code: Optional[str] = None
region: Optional[str] = None
country: Optional[str] = None
latitude: Optional[float] = None
longitude: Optional[float] = None
geonames_id: Optional[str] = None
is_primary: Optional[Union[bool, Bool]] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self.location_type is not None and not isinstance(self.location_type, str):
self.location_type = str(self.location_type)
if self.street_address is not None and not isinstance(self.street_address, str):
self.street_address = str(self.street_address)
if self.city is not None and not isinstance(self.city, str):
self.city = str(self.city)
if self.postal_code is not None and not isinstance(self.postal_code, str):
self.postal_code = str(self.postal_code)
if self.region is not None and not isinstance(self.region, str):
self.region = str(self.region)
if self.country is not None and not isinstance(self.country, str):
self.country = str(self.country)
if self.latitude is not None and not isinstance(self.latitude, float):
self.latitude = float(self.latitude)
if self.longitude is not None and not isinstance(self.longitude, float):
self.longitude = float(self.longitude)
if self.geonames_id is not None and not isinstance(self.geonames_id, str):
self.geonames_id = str(self.geonames_id)
if self.is_primary is not None and not isinstance(self.is_primary, Bool):
self.is_primary = Bool(self.is_primary)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class ContactInfo(YAMLRoot):
"""
Contact information for the organization. Maps to both Schema.org ContactPoint and EU CPOV ContactPoint.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = CPOV["ContactPoint"]
class_class_curie: ClassVar[str] = "cpov:ContactPoint"
class_name: ClassVar[str] = "ContactInfo"
class_model_uri: ClassVar[URIRef] = HERITAGE.ContactInfo
email: Optional[str] = None
phone: Optional[str] = None
fax: Optional[str] = None
contact_type: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self.email is not None and not isinstance(self.email, str):
self.email = str(self.email)
if self.phone is not None and not isinstance(self.phone, str):
self.phone = str(self.phone)
if self.fax is not None and not isinstance(self.fax, str):
self.fax = str(self.fax)
if self.contact_type is not None and not isinstance(self.contact_type, str):
self.contact_type = str(self.contact_type)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Identifier(YAMLRoot):
"""
External identifier for the organization
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = DCTERMS["identifier"]
class_class_curie: ClassVar[str] = "dcterms:identifier"
class_name: ClassVar[str] = "Identifier"
class_model_uri: ClassVar[URIRef] = HERITAGE.Identifier
identifier_scheme: str = None
identifier_value: str = None
identifier_url: Optional[Union[str, URI]] = None
assigned_date: Optional[Union[str, XSDDate]] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.identifier_scheme):
self.MissingRequiredField("identifier_scheme")
if not isinstance(self.identifier_scheme, str):
self.identifier_scheme = str(self.identifier_scheme)
if self._is_empty(self.identifier_value):
self.MissingRequiredField("identifier_value")
if not isinstance(self.identifier_value, str):
self.identifier_value = str(self.identifier_value)
if self.identifier_url is not None and not isinstance(self.identifier_url, URI):
self.identifier_url = URI(self.identifier_url)
if self.assigned_date is not None and not isinstance(self.assigned_date, XSDDate):
self.assigned_date = XSDDate(self.assigned_date)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class OrganizationalUnit(YAMLRoot):
"""
A sub-unit, department, or division within a heritage institution. Examples: Conservation department, Special
Collections, Reading Room. Uses W3C Org Ontology patterns for organizational structure.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = ORG["OrganizationalUnit"]
class_class_curie: ClassVar[str] = "org:OrganizationalUnit"
class_name: ClassVar[str] = "OrganizationalUnit"
class_model_uri: ClassVar[URIRef] = HERITAGE.OrganizationalUnit
unit_id: Union[str, OrganizationalUnitUnitId] = None
unit_name: str = None
unit_type: Optional[str] = None
parent_unit: Optional[Union[str, OrganizationalUnitUnitId]] = None
description: Optional[str] = None
contact_info: Optional[Union[dict, ContactInfo]] = None
homepage: Optional[Union[str, URI]] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.unit_id):
self.MissingRequiredField("unit_id")
if not isinstance(self.unit_id, OrganizationalUnitUnitId):
self.unit_id = OrganizationalUnitUnitId(self.unit_id)
if self._is_empty(self.unit_name):
self.MissingRequiredField("unit_name")
if not isinstance(self.unit_name, str):
self.unit_name = str(self.unit_name)
if self.unit_type is not None and not isinstance(self.unit_type, str):
self.unit_type = str(self.unit_type)
if self.parent_unit is not None and not isinstance(self.parent_unit, OrganizationalUnitUnitId):
self.parent_unit = OrganizationalUnitUnitId(self.parent_unit)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
if self.contact_info is not None and not isinstance(self.contact_info, ContactInfo):
self.contact_info = ContactInfo(**as_dict(self.contact_info))
if self.homepage is not None and not isinstance(self.homepage, URI):
self.homepage = URI(self.homepage)
super().__post_init__(**kwargs)
class ProvenanceEntity(YAMLRoot):
"""
Local proxy for prov:Entity. Represents a physical, digital, conceptual, or other kind of thing with fixed
aspects. Used as mixin for classes that need PROV-O alignment (e.g., HeritageCustodian).
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = PROV["Entity"]
class_class_curie: ClassVar[str] = "prov:Entity"
class_name: ClassVar[str] = "ProvenanceEntity"
class_model_uri: ClassVar[URIRef] = HERITAGE.ProvenanceEntity
class ProvenanceActivity(YAMLRoot):
"""
Local proxy for prov:Activity. Represents something that occurs over a period of time and acts upon or with
entities. Used as base for ChangeEvent.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = PROV["Activity"]
class_class_curie: ClassVar[str] = "prov:Activity"
class_name: ClassVar[str] = "ProvenanceActivity"
class_model_uri: ClassVar[URIRef] = HERITAGE.ProvenanceActivity
class TOOIWijzigingsgebeurtenis(YAMLRoot):
"""
Local proxy for tooi:Wijzigingsgebeurtenis (Change Event in TOOI ontology). Represents organizational change
events in Dutch government organizations. Used as mixin for ChangeEvent to align with TOOI patterns.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = TOOIONT["Wijzigingsgebeurtenis"]
class_class_curie: ClassVar[str] = "tooi:Wijzigingsgebeurtenis"
class_name: ClassVar[str] = "TOOIWijzigingsgebeurtenis"
class_model_uri: ClassVar[URIRef] = HERITAGE.TOOIWijzigingsgebeurtenis
@dataclass(repr=False)
class Provenance(YAMLRoot):
"""
Provenance information for data quality tracking
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = HERITAGE["Provenance"]
class_class_curie: ClassVar[str] = "heritage:Provenance"
class_name: ClassVar[str] = "Provenance"
class_model_uri: ClassVar[URIRef] = HERITAGE.Provenance
data_source: Union[str, "DataSourceEnum"] = None
data_tier: Union[str, "DataTierEnum"] = None
extraction_date: Union[str, XSDDateTime] = None
extraction_method: Optional[str] = None
confidence_score: Optional[float] = None
conversation_id: Optional[str] = None
source_url: Optional[Union[str, URI]] = None
verified_date: Optional[Union[str, XSDDateTime]] = None
verified_by: Optional[str] = None
enrichment_history: Optional[Union[Union[dict, "EnrichmentHistoryEntry"], list[Union[dict, "EnrichmentHistoryEntry"]]]] = empty_list()
provenance_notes: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.data_source):
self.MissingRequiredField("data_source")
if not isinstance(self.data_source, DataSourceEnum):
self.data_source = DataSourceEnum(self.data_source)
if self._is_empty(self.data_tier):
self.MissingRequiredField("data_tier")
if not isinstance(self.data_tier, DataTierEnum):
self.data_tier = DataTierEnum(self.data_tier)
if self._is_empty(self.extraction_date):
self.MissingRequiredField("extraction_date")
if not isinstance(self.extraction_date, XSDDateTime):
self.extraction_date = XSDDateTime(self.extraction_date)
if self.extraction_method is not None and not isinstance(self.extraction_method, str):
self.extraction_method = str(self.extraction_method)
if self.confidence_score is not None and not isinstance(self.confidence_score, float):
self.confidence_score = float(self.confidence_score)
if self.conversation_id is not None and not isinstance(self.conversation_id, str):
self.conversation_id = str(self.conversation_id)
if self.source_url is not None and not isinstance(self.source_url, URI):
self.source_url = URI(self.source_url)
if self.verified_date is not None and not isinstance(self.verified_date, XSDDateTime):
self.verified_date = XSDDateTime(self.verified_date)
if self.verified_by is not None and not isinstance(self.verified_by, str):
self.verified_by = str(self.verified_by)
if not isinstance(self.enrichment_history, list):
self.enrichment_history = [self.enrichment_history] if self.enrichment_history is not None else []
self.enrichment_history = [v if isinstance(v, EnrichmentHistoryEntry) else EnrichmentHistoryEntry(**as_dict(v)) for v in self.enrichment_history]
if self.provenance_notes is not None and not isinstance(self.provenance_notes, str):
self.provenance_notes = str(self.provenance_notes)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class EnrichmentHistoryEntry(YAMLRoot):
"""
Record of a data enrichment activity (e.g., Wikidata lookup, geocoding, identifier resolution). Tracks what was
enriched, when, how, and with what quality metrics.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = HERITAGE["EnrichmentHistoryEntry"]
class_class_curie: ClassVar[str] = "heritage:EnrichmentHistoryEntry"
class_name: ClassVar[str] = "EnrichmentHistoryEntry"
class_model_uri: ClassVar[URIRef] = HERITAGE.EnrichmentHistoryEntry
enrichment_date: Union[str, XSDDateTime] = None
enrichment_method: str = None
enrichment_type: Union[str, "EnrichmentTypeEnum"] = None
verified: Union[bool, Bool] = None
match_score: Optional[float] = None
enrichment_source: Optional[Union[str, URI]] = None
enrichment_notes: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.enrichment_date):
self.MissingRequiredField("enrichment_date")
if not isinstance(self.enrichment_date, XSDDateTime):
self.enrichment_date = XSDDateTime(self.enrichment_date)
if self._is_empty(self.enrichment_method):
self.MissingRequiredField("enrichment_method")
if not isinstance(self.enrichment_method, str):
self.enrichment_method = str(self.enrichment_method)
if self._is_empty(self.enrichment_type):
self.MissingRequiredField("enrichment_type")
if not isinstance(self.enrichment_type, EnrichmentTypeEnum):
self.enrichment_type = EnrichmentTypeEnum(self.enrichment_type)
if self._is_empty(self.verified):
self.MissingRequiredField("verified")
if not isinstance(self.verified, Bool):
self.verified = Bool(self.verified)
if self.match_score is not None and not isinstance(self.match_score, float):
self.match_score = float(self.match_score)
if self.enrichment_source is not None and not isinstance(self.enrichment_source, URI):
self.enrichment_source = URI(self.enrichment_source)
if self.enrichment_notes is not None and not isinstance(self.enrichment_notes, str):
self.enrichment_notes = str(self.enrichment_notes)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class GHCIDHistoryEntry(YAMLRoot):
"""
Historical record tracking GHCID changes over time. Each entry represents a period when a specific GHCID was valid
for this institution.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = HERITAGE["GHCIDHistoryEntry"]
class_class_curie: ClassVar[str] = "heritage:GHCIDHistoryEntry"
class_name: ClassVar[str] = "GHCIDHistoryEntry"
class_model_uri: ClassVar[URIRef] = HERITAGE.GHCIDHistoryEntry
ghcid: str = None
ghcid_numeric: int = None
valid_from: Union[str, XSDDateTime] = None
reason: str = None
institution_name: str = None
location_city: str = None
location_country: str = None
valid_to: Optional[Union[str, XSDDateTime]] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.ghcid):
self.MissingRequiredField("ghcid")
if not isinstance(self.ghcid, str):
self.ghcid = str(self.ghcid)
if self._is_empty(self.ghcid_numeric):
self.MissingRequiredField("ghcid_numeric")
if not isinstance(self.ghcid_numeric, int):
self.ghcid_numeric = int(self.ghcid_numeric)
if self._is_empty(self.valid_from):
self.MissingRequiredField("valid_from")
if not isinstance(self.valid_from, XSDDateTime):
self.valid_from = XSDDateTime(self.valid_from)
if self._is_empty(self.reason):
self.MissingRequiredField("reason")
if not isinstance(self.reason, str):
self.reason = str(self.reason)
if self._is_empty(self.institution_name):
self.MissingRequiredField("institution_name")
if not isinstance(self.institution_name, str):
self.institution_name = str(self.institution_name)
if self._is_empty(self.location_city):
self.MissingRequiredField("location_city")
if not isinstance(self.location_city, str):
self.location_city = str(self.location_city)
if self._is_empty(self.location_country):
self.MissingRequiredField("location_country")
if not isinstance(self.location_country, str):
self.location_country = str(self.location_country)
if self.valid_to is not None and not isinstance(self.valid_to, XSDDateTime):
self.valid_to = XSDDateTime(self.valid_to)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class ChangeEvent(ProvenanceActivity):
"""
A significant organizational change event in an institution's lifecycle. Based on TOOI Wijzigingsgebeurtenis and
W3C PROV-O Activity patterns. Tracks mergers, name changes, relocations, and other structural changes.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = HERITAGE["ChangeEvent"]
class_class_curie: ClassVar[str] = "heritage:ChangeEvent"
class_name: ClassVar[str] = "ChangeEvent"
class_model_uri: ClassVar[URIRef] = HERITAGE.ChangeEvent
event_id: Union[str, ChangeEventEventId] = None
change_type: Union[str, "ChangeTypeEnum"] = None
event_date: Union[str, XSDDate] = None
event_description: Optional[str] = None
affected_organization: Optional[Union[str, HeritageCustodianId]] = None
resulting_organization: Optional[Union[str, HeritageCustodianId]] = None
related_organizations: Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]] = empty_list()
source_documentation: Optional[Union[str, URI]] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.event_id):
self.MissingRequiredField("event_id")
if not isinstance(self.event_id, ChangeEventEventId):
self.event_id = ChangeEventEventId(self.event_id)
if self._is_empty(self.change_type):
self.MissingRequiredField("change_type")
if not isinstance(self.change_type, ChangeTypeEnum):
self.change_type = ChangeTypeEnum(self.change_type)
if self._is_empty(self.event_date):
self.MissingRequiredField("event_date")
if not isinstance(self.event_date, XSDDate):
self.event_date = XSDDate(self.event_date)
if self.event_description is not None and not isinstance(self.event_description, str):
self.event_description = str(self.event_description)
if self.affected_organization is not None and not isinstance(self.affected_organization, HeritageCustodianId):
self.affected_organization = HeritageCustodianId(self.affected_organization)
if self.resulting_organization is not None and not isinstance(self.resulting_organization, HeritageCustodianId):
self.resulting_organization = HeritageCustodianId(self.resulting_organization)
if not isinstance(self.related_organizations, list):
self.related_organizations = [self.related_organizations] if self.related_organizations is not None else []
self.related_organizations = [v if isinstance(v, HeritageCustodianId) else HeritageCustodianId(v) for v in self.related_organizations]
if self.source_documentation is not None and not isinstance(self.source_documentation, URI):
self.source_documentation = URI(self.source_documentation)
super().__post_init__(**kwargs)
class RiCRecordSet(YAMLRoot):
"""
Local proxy for rico:RecordSet. Represents an aggregation of archival records with a common provenance or
assembled for a specific purpose. Used as mixin for Collection class to align with RiC-O archival description
standards.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = RICO["RecordSet"]
class_class_curie: ClassVar[str] = "rico:RecordSet"
class_name: ClassVar[str] = "RiCRecordSet"
class_model_uri: ClassVar[URIRef] = HERITAGE.RiCRecordSet
@dataclass(repr=False)
class Collection(YAMLRoot):
"""
A collection held by the heritage custodian. Maps to RiC-O RecordSet for archives, BIBFRAME Collection for
libraries, and Schema.org Collection for general use. Implements rico:hasOrHadHolder to link back to custodial
organization.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = SCHEMA["Collection"]
class_class_curie: ClassVar[str] = "schema:Collection"
class_name: ClassVar[str] = "Collection"
class_model_uri: ClassVar[URIRef] = HERITAGE.Collection
collection_id: Optional[str] = None
collection_name: Optional[str] = None
collection_description: Optional[str] = None
collection_type: Optional[str] = None
item_count: Optional[str] = None
subjects: Optional[Union[str, list[str]]] = empty_list()
time_period_start: Optional[Union[str, XSDDate]] = None
time_period_end: Optional[Union[str, XSDDate]] = None
temporal_coverage: Optional[str] = None
access_rights: Optional[str] = None
catalog_url: Optional[Union[str, URI]] = None
custodian: Optional[Union[str, HeritageCustodianId]] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self.collection_id is not None and not isinstance(self.collection_id, str):
self.collection_id = str(self.collection_id)
if self.collection_name is not None and not isinstance(self.collection_name, str):
self.collection_name = str(self.collection_name)
if self.collection_description is not None and not isinstance(self.collection_description, str):
self.collection_description = str(self.collection_description)
if self.collection_type is not None and not isinstance(self.collection_type, str):
self.collection_type = str(self.collection_type)
if self.item_count is not None and not isinstance(self.item_count, str):
self.item_count = str(self.item_count)
if not isinstance(self.subjects, list):
self.subjects = [self.subjects] if self.subjects is not None else []
self.subjects = [v if isinstance(v, str) else str(v) for v in self.subjects]
if self.time_period_start is not None and not isinstance(self.time_period_start, XSDDate):
self.time_period_start = XSDDate(self.time_period_start)
if self.time_period_end is not None and not isinstance(self.time_period_end, XSDDate):
self.time_period_end = XSDDate(self.time_period_end)
if self.temporal_coverage is not None and not isinstance(self.temporal_coverage, str):
self.temporal_coverage = str(self.temporal_coverage)
if self.access_rights is not None and not isinstance(self.access_rights, str):
self.access_rights = str(self.access_rights)
if self.catalog_url is not None and not isinstance(self.catalog_url, URI):
self.catalog_url = URI(self.catalog_url)
if self.custodian is not None and not isinstance(self.custodian, HeritageCustodianId):
self.custodian = HeritageCustodianId(self.custodian)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class DigitalPlatform(YAMLRoot):
"""
Digital platform or system used by the institution
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = SCHEMA["SoftwareApplication"]
class_class_curie: ClassVar[str] = "schema:SoftwareApplication"
class_name: ClassVar[str] = "DigitalPlatform"
class_model_uri: ClassVar[URIRef] = HERITAGE.DigitalPlatform
platform_name: Optional[str] = None
platform_type: Optional[Union[str, "DigitalPlatformTypeEnum"]] = None
platform_url: Optional[Union[str, URI]] = None
platform_description: Optional[str] = None
vendor: Optional[str] = None
integration_method: Optional[str] = None
implemented_standards: Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]] = empty_list()
def __post_init__(self, *_: str, **kwargs: Any):
if self.platform_name is not None and not isinstance(self.platform_name, str):
self.platform_name = str(self.platform_name)
if self.platform_type is not None and not isinstance(self.platform_type, DigitalPlatformTypeEnum):
self.platform_type = DigitalPlatformTypeEnum(self.platform_type)
if self.platform_url is not None and not isinstance(self.platform_url, URI):
self.platform_url = URI(self.platform_url)
if self.platform_description is not None and not isinstance(self.platform_description, str):
self.platform_description = str(self.platform_description)
if self.vendor is not None and not isinstance(self.vendor, str):
self.vendor = str(self.vendor)
if self.integration_method is not None and not isinstance(self.integration_method, str):
self.integration_method = str(self.integration_method)
if not isinstance(self.implemented_standards, list):
self.implemented_standards = [self.implemented_standards] if self.implemented_standards is not None else []
self.implemented_standards = [v if isinstance(v, MetadataStandardEnum) else MetadataStandardEnum(v) for v in self.implemented_standards]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Partnership(YAMLRoot):
"""
Partnership or network membership
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = ORG["Membership"]
class_class_curie: ClassVar[str] = "org:Membership"
class_name: ClassVar[str] = "Partnership"
class_model_uri: ClassVar[URIRef] = HERITAGE.Partnership
partner_name: Optional[str] = None
partner_id: Optional[Union[str, URIorCURIE]] = None
partnership_type: Optional[str] = None
start_date: Optional[Union[str, XSDDate]] = None
end_date: Optional[Union[str, XSDDate]] = None
description: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self.partner_name is not None and not isinstance(self.partner_name, str):
self.partner_name = str(self.partner_name)
if self.partner_id is not None and not isinstance(self.partner_id, URIorCURIE):
self.partner_id = URIorCURIE(self.partner_id)
if self.partnership_type is not None and not isinstance(self.partnership_type, str):
self.partnership_type = str(self.partnership_type)
if self.start_date is not None and not isinstance(self.start_date, XSDDate):
self.start_date = XSDDate(self.start_date)
if self.end_date is not None and not isinstance(self.end_date, XSDDate):
self.end_date = XSDDate(self.end_date)
if self.description is not None and not isinstance(self.description, str):
self.description = str(self.description)
super().__post_init__(**kwargs)
class TOOIOverheidsorganisatie(YAMLRoot):
"""
Local proxy for tooi:Overheidsorganisatie (Government Organization in TOOI ontology). Represents Dutch public
sector organizations with government affiliation. Used as mixin for DutchHeritageCustodian to align with TOOI
patterns.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = TOOIONT["Overheidsorganisatie"]
class_class_curie: ClassVar[str] = "tooi:Overheidsorganisatie"
class_name: ClassVar[str] = "TOOIOverheidsorganisatie"
class_model_uri: ClassVar[URIRef] = HERITAGE.TOOIOverheidsorganisatie
@dataclass(repr=False)
class DutchHeritageCustodian(HeritageCustodian):
"""
A heritage custodian organization based in the Netherlands, with additional Dutch-specific identification and
organizational metadata. Integrates with TOOI (Thesaurus Overheidsorganisaties) for public sector organizations.
Network memberships and thematic partnerships are represented using the universal Partnership class (not
Dutch-specific boolean flags).
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = HERITAGE["DutchHeritageCustodian"]
class_class_curie: ClassVar[str] = "heritage:DutchHeritageCustodian"
class_name: ClassVar[str] = "DutchHeritageCustodian"
class_model_uri: ClassVar[URIRef] = HERITAGE.DutchHeritageCustodian
id: Union[str, DutchHeritageCustodianId] = None
name: str = None
institution_type: Union[str, "InstitutionTypeEnum"] = None
provenance: Union[dict, Provenance] = None
kvk_number: Optional[str] = None
gemeente_code: Optional[str] = None
identifiers: Optional[Union[Union[dict, Identifier], list[Union[dict, Identifier]]]] = empty_list()
partnerships: Optional[Union[Union[dict, Partnership], list[Union[dict, Partnership]]]] = empty_list()
locations: Optional[Union[Union[dict, Location], list[Union[dict, Location]]]] = empty_list()
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.id):
self.MissingRequiredField("id")
if not isinstance(self.id, DutchHeritageCustodianId):
self.id = DutchHeritageCustodianId(self.id)
if self.kvk_number is not None and not isinstance(self.kvk_number, str):
self.kvk_number = str(self.kvk_number)
if self.gemeente_code is not None and not isinstance(self.gemeente_code, str):
self.gemeente_code = str(self.gemeente_code)
if not isinstance(self.identifiers, list):
self.identifiers = [self.identifiers] if self.identifiers is not None else []
self.identifiers = [v if isinstance(v, Identifier) else Identifier(**as_dict(v)) for v in self.identifiers]
if not isinstance(self.partnerships, list):
self.partnerships = [self.partnerships] if self.partnerships is not None else []
self.partnerships = [v if isinstance(v, Partnership) else Partnership(**as_dict(v)) for v in self.partnerships]
if not isinstance(self.locations, list):
self.locations = [self.locations] if self.locations is not None else []
self.locations = [v if isinstance(v, Location) else Location(**as_dict(v)) for v in self.locations]
super().__post_init__(**kwargs)
class FRBRWork(YAMLRoot):
"""
Local proxy for frbr:Work (FRBR Work entity). Represents the abstract intellectual essence of a work, independent
of any specific expression, manifestation, or item. Used as mixin for ScholarlyWork.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FRBR["Work"]
class_class_curie: ClassVar[str] = "frbr:Work"
class_name: ClassVar[str] = "FRBRWork"
class_model_uri: ClassVar[URIRef] = HERITAGE.FRBRWork
class FRBRExpression(YAMLRoot):
"""
Local proxy for frbr:Expression (FRBR Expression entity). Represents a specific intellectual or artistic
realization of a work (e.g., the English translation, the revised edition). Used as mixin for Publication.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FRBR["Expression"]
class_class_curie: ClassVar[str] = "frbr:Expression"
class_name: ClassVar[str] = "FRBRExpression"
class_model_uri: ClassVar[URIRef] = HERITAGE.FRBRExpression
class BiBOJournal(YAMLRoot):
"""
Local proxy for bibo:Journal (Bibliographic Ontology Journal class). Represents a scholarly journal or periodical
publication.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = BIBO["Journal"]
class_class_curie: ClassVar[str] = "bibo:Journal"
class_name: ClassVar[str] = "BiBOJournal"
class_model_uri: ClassVar[URIRef] = HERITAGE.BiBOJournal
class BiBOConference(YAMLRoot):
"""
Local proxy for bibo:Conference (Bibliographic Ontology Conference class). Represents an academic conference or
symposium.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = BIBO["Conference"]
class_class_curie: ClassVar[str] = "bibo:Conference"
class_name: ClassVar[str] = "BiBOConference"
class_model_uri: ClassVar[URIRef] = HERITAGE.BiBOConference
class BiBOBibliographicReference(YAMLRoot):
"""
Local proxy for biro:BibliographicReference (BiRO bibliographic reference). Represents a bibliographic reference
or citation.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = BIRO["BibliographicReference"]
class_class_curie: ClassVar[str] = "biro:BibliographicReference"
class_name: ClassVar[str] = "BiBOBibliographicReference"
class_model_uri: ClassVar[URIRef] = HERITAGE.BiBOBibliographicReference
@dataclass(repr=False)
class ScholarlyWork(YAMLRoot):
"""
Abstract intellectual creation representing a scholarly work (FRBR Work level). FaBiO concept for the conceptual
essence of a publication, independent of its specific expressions or manifestations.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FABIO["Work"]
class_class_curie: ClassVar[str] = "fabio:Work"
class_name: ClassVar[str] = "ScholarlyWork"
class_model_uri: ClassVar[URIRef] = HERITAGE.ScholarlyWork
work_id: Union[str, ScholarlyWorkWorkId] = None
provenance: Union[dict, Provenance] = None
work_title: Optional[str] = None
work_subject: Optional[Union[str, list[str]]] = empty_list()
work_keywords: Optional[Union[str, list[str]]] = empty_list()
abstract: Optional[str] = None
discipline: Optional[Union[str, list[str]]] = empty_list()
research_field: Optional[Union[str, list[str]]] = empty_list()
has_expression: Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]] = empty_list()
related_institutions: Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]] = empty_list()
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.work_id):
self.MissingRequiredField("work_id")
if not isinstance(self.work_id, ScholarlyWorkWorkId):
self.work_id = ScholarlyWorkWorkId(self.work_id)
if self._is_empty(self.provenance):
self.MissingRequiredField("provenance")
if not isinstance(self.provenance, Provenance):
self.provenance = Provenance(**as_dict(self.provenance))
if self.work_title is not None and not isinstance(self.work_title, str):
self.work_title = str(self.work_title)
if not isinstance(self.work_subject, list):
self.work_subject = [self.work_subject] if self.work_subject is not None else []
self.work_subject = [v if isinstance(v, str) else str(v) for v in self.work_subject]
if not isinstance(self.work_keywords, list):
self.work_keywords = [self.work_keywords] if self.work_keywords is not None else []
self.work_keywords = [v if isinstance(v, str) else str(v) for v in self.work_keywords]
if self.abstract is not None and not isinstance(self.abstract, str):
self.abstract = str(self.abstract)
if not isinstance(self.discipline, list):
self.discipline = [self.discipline] if self.discipline is not None else []
self.discipline = [v if isinstance(v, str) else str(v) for v in self.discipline]
if not isinstance(self.research_field, list):
self.research_field = [self.research_field] if self.research_field is not None else []
self.research_field = [v if isinstance(v, str) else str(v) for v in self.research_field]
if not isinstance(self.has_expression, list):
self.has_expression = [self.has_expression] if self.has_expression is not None else []
self.has_expression = [v if isinstance(v, PublicationPublicationId) else PublicationPublicationId(v) for v in self.has_expression]
if not isinstance(self.related_institutions, list):
self.related_institutions = [self.related_institutions] if self.related_institutions is not None else []
self.related_institutions = [v if isinstance(v, HeritageCustodianId) else HeritageCustodianId(v) for v in self.related_institutions]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Publication(YAMLRoot):
"""
Concrete realization of a scholarly work (FRBR Expression level). Represents a specific version or edition of a
work with authors, publication date, and citation metadata. FaBiO Expression pattern.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FABIO["Expression"]
class_class_curie: ClassVar[str] = "fabio:Expression"
class_name: ClassVar[str] = "Publication"
class_model_uri: ClassVar[URIRef] = HERITAGE.Publication
publication_id: Union[str, PublicationPublicationId] = None
title: str = None
publication_type: Union[str, "PublicationTypeEnum"] = None
provenance: Union[dict, Provenance] = None
alternative_titles: Optional[Union[str, list[str]]] = empty_list()
authors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict()
editors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict()
contributors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict()
publication_date: Optional[Union[str, XSDDate]] = None
publication_year: Optional[int] = None
abstract: Optional[str] = None
keywords: Optional[Union[str, list[str]]] = empty_list()
language: Optional[str] = None
doi: Optional[str] = None
url: Optional[Union[str, URI]] = None
published_in: Optional[Union[str, JournalJournalId]] = None
volume: Optional[str] = None
issue: Optional[str] = None
page_range: Optional[str] = None
article_number: Optional[str] = None
publisher: Optional[Union[dict, "Organization"]] = None
place_of_publication: Optional[str] = None
isbn: Optional[str] = None
issn: Optional[str] = None
citations: Optional[Union[dict[Union[str, CitationCitationId], Union[dict, "Citation"]], list[Union[dict, "Citation"]]]] = empty_dict()
cited_by: Optional[Union[Union[str, CitationCitationId], list[Union[str, CitationCitationId]]]] = empty_list()
related_works: Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]] = empty_list()
document_sections: Optional[Union[dict[Union[str, DocumentSectionSectionId], Union[dict, "DocumentSection"]], list[Union[dict, "DocumentSection"]]]] = empty_dict()
open_access_status: Optional[Union[str, "OpenAccessStatusEnum"]] = None
publishing_status: Optional[Union[str, "PublishingStatusEnum"]] = None
peer_reviewed: Optional[Union[bool, Bool]] = None
license: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.publication_id):
self.MissingRequiredField("publication_id")
if not isinstance(self.publication_id, PublicationPublicationId):
self.publication_id = PublicationPublicationId(self.publication_id)
if self._is_empty(self.title):
self.MissingRequiredField("title")
if not isinstance(self.title, str):
self.title = str(self.title)
if self._is_empty(self.publication_type):
self.MissingRequiredField("publication_type")
if not isinstance(self.publication_type, PublicationTypeEnum):
self.publication_type = PublicationTypeEnum(self.publication_type)
if self._is_empty(self.provenance):
self.MissingRequiredField("provenance")
if not isinstance(self.provenance, Provenance):
self.provenance = Provenance(**as_dict(self.provenance))
if not isinstance(self.alternative_titles, list):
self.alternative_titles = [self.alternative_titles] if self.alternative_titles is not None else []
self.alternative_titles = [v if isinstance(v, str) else str(v) for v in self.alternative_titles]
self._normalize_inlined_as_list(slot_name="authors", slot_type=Person, key_name="person_id", keyed=True)
self._normalize_inlined_as_list(slot_name="editors", slot_type=Person, key_name="person_id", keyed=True)
self._normalize_inlined_as_list(slot_name="contributors", slot_type=Person, key_name="person_id", keyed=True)
if self.publication_date is not None and not isinstance(self.publication_date, XSDDate):
self.publication_date = XSDDate(self.publication_date)
if self.publication_year is not None and not isinstance(self.publication_year, int):
self.publication_year = int(self.publication_year)
if self.abstract is not None and not isinstance(self.abstract, str):
self.abstract = str(self.abstract)
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]
if self.language is not None and not isinstance(self.language, str):
self.language = str(self.language)
if self.doi is not None and not isinstance(self.doi, str):
self.doi = str(self.doi)
if self.url is not None and not isinstance(self.url, URI):
self.url = URI(self.url)
if self.published_in is not None and not isinstance(self.published_in, JournalJournalId):
self.published_in = JournalJournalId(self.published_in)
if self.volume is not None and not isinstance(self.volume, str):
self.volume = str(self.volume)
if self.issue is not None and not isinstance(self.issue, str):
self.issue = str(self.issue)
if self.page_range is not None and not isinstance(self.page_range, str):
self.page_range = str(self.page_range)
if self.article_number is not None and not isinstance(self.article_number, str):
self.article_number = str(self.article_number)
if self.publisher is not None and not isinstance(self.publisher, Organization):
self.publisher = Organization(**as_dict(self.publisher))
if self.place_of_publication is not None and not isinstance(self.place_of_publication, str):
self.place_of_publication = str(self.place_of_publication)
if self.isbn is not None and not isinstance(self.isbn, str):
self.isbn = str(self.isbn)
if self.issn is not None and not isinstance(self.issn, str):
self.issn = str(self.issn)
self._normalize_inlined_as_list(slot_name="citations", slot_type=Citation, key_name="citation_id", keyed=True)
if not isinstance(self.cited_by, list):
self.cited_by = [self.cited_by] if self.cited_by is not None else []
self.cited_by = [v if isinstance(v, CitationCitationId) else CitationCitationId(v) for v in self.cited_by]
if not isinstance(self.related_works, list):
self.related_works = [self.related_works] if self.related_works is not None else []
self.related_works = [v if isinstance(v, PublicationPublicationId) else PublicationPublicationId(v) for v in self.related_works]
self._normalize_inlined_as_list(slot_name="document_sections", slot_type=DocumentSection, key_name="section_id", keyed=True)
if self.open_access_status is not None and not isinstance(self.open_access_status, OpenAccessStatusEnum):
self.open_access_status = OpenAccessStatusEnum(self.open_access_status)
if self.publishing_status is not None and not isinstance(self.publishing_status, PublishingStatusEnum):
self.publishing_status = PublishingStatusEnum(self.publishing_status)
if self.peer_reviewed is not None and not isinstance(self.peer_reviewed, Bool):
self.peer_reviewed = Bool(self.peer_reviewed)
if self.license is not None and not isinstance(self.license, str):
self.license = str(self.license)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Journal(YAMLRoot):
"""
Academic journal or periodical publication. FaBiO Journal class representing a continuing resource published in
serial fashion.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FABIO["Journal"]
class_class_curie: ClassVar[str] = "fabio:Journal"
class_name: ClassVar[str] = "Journal"
class_model_uri: ClassVar[URIRef] = HERITAGE.Journal
journal_id: Union[str, JournalJournalId] = None
journal_title: str = None
provenance: Union[dict, Provenance] = None
alternative_journal_titles: Optional[Union[str, list[str]]] = empty_list()
issn: Optional[str] = None
eissn: Optional[str] = None
publisher: Optional[Union[dict, "Organization"]] = None
journal_url: Optional[Union[str, URI]] = None
impact_factor: Optional[float] = None
cite_score: Optional[float] = None
subject_areas: Optional[Union[str, list[str]]] = empty_list()
open_access_status: Optional[Union[str, "OpenAccessStatusEnum"]] = None
indexing_services: Optional[Union[str, list[str]]] = empty_list()
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.journal_id):
self.MissingRequiredField("journal_id")
if not isinstance(self.journal_id, JournalJournalId):
self.journal_id = JournalJournalId(self.journal_id)
if self._is_empty(self.journal_title):
self.MissingRequiredField("journal_title")
if not isinstance(self.journal_title, str):
self.journal_title = str(self.journal_title)
if self._is_empty(self.provenance):
self.MissingRequiredField("provenance")
if not isinstance(self.provenance, Provenance):
self.provenance = Provenance(**as_dict(self.provenance))
if not isinstance(self.alternative_journal_titles, list):
self.alternative_journal_titles = [self.alternative_journal_titles] if self.alternative_journal_titles is not None else []
self.alternative_journal_titles = [v if isinstance(v, str) else str(v) for v in self.alternative_journal_titles]
if self.issn is not None and not isinstance(self.issn, str):
self.issn = str(self.issn)
if self.eissn is not None and not isinstance(self.eissn, str):
self.eissn = str(self.eissn)
if self.publisher is not None and not isinstance(self.publisher, Organization):
self.publisher = Organization(**as_dict(self.publisher))
if self.journal_url is not None and not isinstance(self.journal_url, URI):
self.journal_url = URI(self.journal_url)
if self.impact_factor is not None and not isinstance(self.impact_factor, float):
self.impact_factor = float(self.impact_factor)
if self.cite_score is not None and not isinstance(self.cite_score, float):
self.cite_score = float(self.cite_score)
if not isinstance(self.subject_areas, list):
self.subject_areas = [self.subject_areas] if self.subject_areas is not None else []
self.subject_areas = [v if isinstance(v, str) else str(v) for v in self.subject_areas]
if self.open_access_status is not None and not isinstance(self.open_access_status, OpenAccessStatusEnum):
self.open_access_status = OpenAccessStatusEnum(self.open_access_status)
if not isinstance(self.indexing_services, list):
self.indexing_services = [self.indexing_services] if self.indexing_services is not None else []
self.indexing_services = [v if isinstance(v, str) else str(v) for v in self.indexing_services]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Conference(YAMLRoot):
"""
Academic conference or symposium. FaBiO AcademicProceedings representing a collection of conference papers.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FABIO["AcademicProceedings"]
class_class_curie: ClassVar[str] = "fabio:AcademicProceedings"
class_name: ClassVar[str] = "Conference"
class_model_uri: ClassVar[URIRef] = HERITAGE.Conference
conference_id: Union[str, ConferenceConferenceId] = None
conference_name: str = None
provenance: Union[dict, Provenance] = None
conference_acronym: Optional[str] = None
conference_date: Optional[str] = None
conference_location: Optional[str] = None
conference_url: Optional[Union[str, URI]] = None
proceedings_title: Optional[str] = None
proceedings_isbn: Optional[str] = None
proceedings_publisher: Optional[Union[dict, "Organization"]] = None
editors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict()
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.conference_id):
self.MissingRequiredField("conference_id")
if not isinstance(self.conference_id, ConferenceConferenceId):
self.conference_id = ConferenceConferenceId(self.conference_id)
if self._is_empty(self.conference_name):
self.MissingRequiredField("conference_name")
if not isinstance(self.conference_name, str):
self.conference_name = str(self.conference_name)
if self._is_empty(self.provenance):
self.MissingRequiredField("provenance")
if not isinstance(self.provenance, Provenance):
self.provenance = Provenance(**as_dict(self.provenance))
if self.conference_acronym is not None and not isinstance(self.conference_acronym, str):
self.conference_acronym = str(self.conference_acronym)
if self.conference_date is not None and not isinstance(self.conference_date, str):
self.conference_date = str(self.conference_date)
if self.conference_location is not None and not isinstance(self.conference_location, str):
self.conference_location = str(self.conference_location)
if self.conference_url is not None and not isinstance(self.conference_url, URI):
self.conference_url = URI(self.conference_url)
if self.proceedings_title is not None and not isinstance(self.proceedings_title, str):
self.proceedings_title = str(self.proceedings_title)
if self.proceedings_isbn is not None and not isinstance(self.proceedings_isbn, str):
self.proceedings_isbn = str(self.proceedings_isbn)
if self.proceedings_publisher is not None and not isinstance(self.proceedings_publisher, Organization):
self.proceedings_publisher = Organization(**as_dict(self.proceedings_publisher))
self._normalize_inlined_as_list(slot_name="editors", slot_type=Person, key_name="person_id", keyed=True)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Person(YAMLRoot):
"""
Person involved in scholarly publishing (author, editor, reviewer). FOAF Person with PRO publishing roles.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = FOAF["Person"]
class_class_curie: ClassVar[str] = "foaf:Person"
class_name: ClassVar[str] = "Person"
class_model_uri: ClassVar[URIRef] = HERITAGE.Person
person_id: Union[str, PersonPersonId] = None
person_name: str = None
given_name: Optional[str] = None
family_name: Optional[str] = None
orcid: Optional[str] = None
email: Optional[str] = None
affiliation: Optional[Union[dict, "Organization"]] = None
roles: Optional[Union[Union[dict, "PublishingRole"], list[Union[dict, "PublishingRole"]]]] = empty_list()
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.person_id):
self.MissingRequiredField("person_id")
if not isinstance(self.person_id, PersonPersonId):
self.person_id = PersonPersonId(self.person_id)
if self._is_empty(self.person_name):
self.MissingRequiredField("person_name")
if not isinstance(self.person_name, str):
self.person_name = str(self.person_name)
if self.given_name is not None and not isinstance(self.given_name, str):
self.given_name = str(self.given_name)
if self.family_name is not None and not isinstance(self.family_name, str):
self.family_name = str(self.family_name)
if self.orcid is not None and not isinstance(self.orcid, str):
self.orcid = str(self.orcid)
if self.email is not None and not isinstance(self.email, str):
self.email = str(self.email)
if self.affiliation is not None and not isinstance(self.affiliation, Organization):
self.affiliation = Organization(**as_dict(self.affiliation))
if not isinstance(self.roles, list):
self.roles = [self.roles] if self.roles is not None else []
self.roles = [v if isinstance(v, PublishingRole) else PublishingRole(**as_dict(v)) for v in self.roles]
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Organization(YAMLRoot):
"""
Organization involved in publishing (publisher, institutional affiliation). Schema.org Organization for
bibliographic contexts.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = SCHEMA["Organization"]
class_class_curie: ClassVar[str] = "schema:Organization"
class_name: ClassVar[str] = "Organization"
class_model_uri: ClassVar[URIRef] = HERITAGE.Organization
organization_id: Union[str, OrganizationOrganizationId] = None
organization_name: str = None
organization_type: Optional[str] = None
location: Optional[str] = None
homepage: Optional[Union[str, URI]] = None
ror_id: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.organization_id):
self.MissingRequiredField("organization_id")
if not isinstance(self.organization_id, OrganizationOrganizationId):
self.organization_id = OrganizationOrganizationId(self.organization_id)
if self._is_empty(self.organization_name):
self.MissingRequiredField("organization_name")
if not isinstance(self.organization_name, str):
self.organization_name = str(self.organization_name)
if self.organization_type is not None and not isinstance(self.organization_type, str):
self.organization_type = str(self.organization_type)
if self.location is not None and not isinstance(self.location, str):
self.location = str(self.location)
if self.homepage is not None and not isinstance(self.homepage, URI):
self.homepage = URI(self.homepage)
if self.ror_id is not None and not isinstance(self.ror_id, str):
self.ror_id = str(self.ror_id)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class Citation(YAMLRoot):
"""
Citation relationship between two publications. CiTO Citation characterizing how one work cites another.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = CITO["Citation"]
class_class_curie: ClassVar[str] = "cito:Citation"
class_name: ClassVar[str] = "Citation"
class_model_uri: ClassVar[URIRef] = HERITAGE.Citation
citation_id: Union[str, CitationCitationId] = None
citing_work: Union[str, PublicationPublicationId] = None
cited_work: Union[str, PublicationPublicationId] = None
citation_type: Union[str, "CitationTypeEnum"] = None
citation_intent: Optional[str] = None
citation_context: Optional[str] = None
page_number: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.citation_id):
self.MissingRequiredField("citation_id")
if not isinstance(self.citation_id, CitationCitationId):
self.citation_id = CitationCitationId(self.citation_id)
if self._is_empty(self.citing_work):
self.MissingRequiredField("citing_work")
if not isinstance(self.citing_work, PublicationPublicationId):
self.citing_work = PublicationPublicationId(self.citing_work)
if self._is_empty(self.cited_work):
self.MissingRequiredField("cited_work")
if not isinstance(self.cited_work, PublicationPublicationId):
self.cited_work = PublicationPublicationId(self.cited_work)
if self._is_empty(self.citation_type):
self.MissingRequiredField("citation_type")
if not isinstance(self.citation_type, CitationTypeEnum):
self.citation_type = CitationTypeEnum(self.citation_type)
if self.citation_intent is not None and not isinstance(self.citation_intent, str):
self.citation_intent = str(self.citation_intent)
if self.citation_context is not None and not isinstance(self.citation_context, str):
self.citation_context = str(self.citation_context)
if self.page_number is not None and not isinstance(self.page_number, str):
self.page_number = str(self.page_number)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class DocumentSection(YAMLRoot):
"""
Structural section or component of a document. DoCO Document Component representing abstract, introduction,
methods, etc.
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = DOCO["Section"]
class_class_curie: ClassVar[str] = "doco:Section"
class_name: ClassVar[str] = "DocumentSection"
class_model_uri: ClassVar[URIRef] = HERITAGE.DocumentSection
section_id: Union[str, DocumentSectionSectionId] = None
section_title: Optional[str] = None
section_type: Optional[Union[str, "DocumentSectionTypeEnum"]] = None
section_content: Optional[str] = None
section_order: Optional[int] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.section_id):
self.MissingRequiredField("section_id")
if not isinstance(self.section_id, DocumentSectionSectionId):
self.section_id = DocumentSectionSectionId(self.section_id)
if self.section_title is not None and not isinstance(self.section_title, str):
self.section_title = str(self.section_title)
if self.section_type is not None and not isinstance(self.section_type, DocumentSectionTypeEnum):
self.section_type = DocumentSectionTypeEnum(self.section_type)
if self.section_content is not None and not isinstance(self.section_content, str):
self.section_content = str(self.section_content)
if self.section_order is not None and not isinstance(self.section_order, int):
self.section_order = int(self.section_order)
super().__post_init__(**kwargs)
@dataclass(repr=False)
class PublishingRole(YAMLRoot):
"""
Role of a person or organization in the publishing process. PRO Publishing Role (author, editor, reviewer,
publisher).
"""
_inherited_slots: ClassVar[list[str]] = []
class_class_uri: ClassVar[URIRef] = PRO["PublishingRole"]
class_class_curie: ClassVar[str] = "pro:PublishingRole"
class_name: ClassVar[str] = "PublishingRole"
class_model_uri: ClassVar[URIRef] = HERITAGE.PublishingRole
role_type: Union[str, "PublishingRoleTypeEnum"] = None
role_holder: Union[str, PersonPersonId] = None
role_context: Optional[str] = None
def __post_init__(self, *_: str, **kwargs: Any):
if self._is_empty(self.role_type):
self.MissingRequiredField("role_type")
if not isinstance(self.role_type, PublishingRoleTypeEnum):
self.role_type = PublishingRoleTypeEnum(self.role_type)
if self._is_empty(self.role_holder):
self.MissingRequiredField("role_holder")
if not isinstance(self.role_holder, PersonPersonId):
self.role_holder = PersonPersonId(self.role_holder)
if self.role_context is not None and not isinstance(self.role_context, str):
self.role_context = str(self.role_context)
super().__post_init__(**kwargs)
# Enumerations
class InstitutionTypeEnum(EnumDefinitionImpl):
"""
Types of heritage institutions (GLAMORCUBESFIXPHDNT taxonomy). Uses single-letter codes for GHCID generation:
G(allery), L(ibrary), A(rchive), M(useum), O(fficial), R(esearch), C(orporation), U(nknown),
B(otanical/Zoo), E(ducation), S(ociety), F(eatures), I(ntangible), X(miXed), P(ersonal),
H(oly sites), D(igital), N(GO).
"""
GALLERY = PermissibleValue(
text="GALLERY",
description="Art gallery or exhibition space",
meaning=SCHEMA["ArtGallery"])
LIBRARY = PermissibleValue(
text="LIBRARY",
description="Library (public, academic, specialized)",
meaning=SCHEMA["Library"])
ARCHIVE = PermissibleValue(
text="ARCHIVE",
description="Archive (government, corporate, personal, community)",
meaning=SCHEMA["ArchiveOrganization"])
MUSEUM = PermissibleValue(
text="MUSEUM",
description="Museum (art, history, science, natural history, etc.)",
meaning=SCHEMA["Museum"])
OFFICIAL_INSTITUTION = PermissibleValue(
text="OFFICIAL_INSTITUTION",
description="Official government institutions managing cultural heritage",
meaning=CPOV["PublicOrganisation"])
RESEARCH_CENTER = PermissibleValue(
text="RESEARCH_CENTER",
description="Research centers and institutes focused on cultural/heritage research",
meaning=SCHEMA["ResearchOrganization"])
CORPORATION = PermissibleValue(
text="CORPORATION",
description="Corporate collections and heritage institutions",
meaning=SCHEMA["Corporation"])
UNKNOWN = PermissibleValue(
text="UNKNOWN",
description="Unknown or uncategorized heritage custodian")
BOTANICAL_ZOO = PermissibleValue(
text="BOTANICAL_ZOO",
description="Botanical gardens, zoos, aquariums, and natural heritage sites",
meaning=SCHEMA["Zoo"])
EDUCATION_PROVIDER = PermissibleValue(
text="EDUCATION_PROVIDER",
description="Educational institutions with heritage collections (universities, schools)",
meaning=SCHEMA["EducationalOrganization"])
PERSONAL_COLLECTION = PermissibleValue(
text="PERSONAL_COLLECTION",
description="Personal or private collections",
meaning=SCHEMA["Collection"])
COLLECTING_SOCIETY = PermissibleValue(
text="COLLECTING_SOCIETY",
description="""Collecting societies (numismatics, philately, ephemera, local history/heemkundige kring, memorabilia, vintage, philographic)""",
meaning=SCHEMA["Organization"])
MIXED = PermissibleValue(
text="MIXED",
description="""Multi-type institution (e.g., library + archive + museum). Use primary type for GHCID; document mixed nature in description.""")
HOLY_SITES = PermissibleValue(
text="HOLY_SITES",
description="""Religious and sacred heritage sites (churches, temples, mosques, synagogues, shrines, monasteries, cathedrals) with historical, architectural, or cultural significance.""",
meaning=SCHEMA["PlaceOfWorship"])
FEATURES = PermissibleValue(
text="FEATURES",
description="""Physical landscape features with heritage significance (monuments, sculptures, statues, memorials, landmarks, cemeteries as physical features). Distinct from institutions that maintain collections.""",
meaning=SCHEMA["Monument"])
_defn = EnumDefinition(
name="InstitutionTypeEnum",
description="""Types of heritage institutions (GLAMORCUBESFIXPHDNT taxonomy). Uses single-letter codes for GHCID generation: G(allery), L(ibrary), A(rchive), M(useum), O(fficial), R(esearch), C(orporation), U(nknown), B(otanical/Zoo), E(ducation), S(ociety), F(eatures), I(ntangible), X(miXed), P(ersonal), H(oly sites), D(igital), N(GO), T(aste/smell).""",
)
class OrganizationStatusEnum(EnumDefinitionImpl):
"""
Operational status of the organization
"""
ACTIVE = PermissibleValue(
text="ACTIVE",
description="Currently operational")
INACTIVE = PermissibleValue(
text="INACTIVE",
description="No longer operational")
MERGED = PermissibleValue(
text="MERGED",
description="Merged with another organization")
SUSPENDED = PermissibleValue(
text="SUSPENDED",
description="Temporarily suspended operations")
PLANNED = PermissibleValue(
text="PLANNED",
description="Planned but not yet operational")
UNKNOWN = PermissibleValue(
text="UNKNOWN",
description="Status unknown")
_defn = EnumDefinition(
name="OrganizationStatusEnum",
description="Operational status of the organization",
)
class DataSourceEnum(EnumDefinitionImpl):
"""
Source of the data (for provenance tracking)
"""
ISIL_REGISTRY = PermissibleValue(
text="ISIL_REGISTRY",
description="Official ISIL code registry")
DUTCH_ORG_CSV = PermissibleValue(
text="DUTCH_ORG_CSV",
description="Dutch heritage organizations CSV (totaallijst_nederland)")
CONVERSATION_NLP = PermissibleValue(
text="CONVERSATION_NLP",
description="Extracted from Claude conversation via NLP")
WEB_CRAWL = PermissibleValue(
text="WEB_CRAWL",
description="Extracted from institutional website via crawl4ai")
WIKIDATA = PermissibleValue(
text="WIKIDATA",
description="Sourced from Wikidata SPARQL query")
MANUAL_ENTRY = PermissibleValue(
text="MANUAL_ENTRY",
description="Manually entered or curated")
INFERRED = PermissibleValue(
text="INFERRED",
description="Inferred from other data points")
CSV_REGISTRY = PermissibleValue(
text="CSV_REGISTRY",
description="General CSV registry or dataset")
_defn = EnumDefinition(
name="DataSourceEnum",
description="Source of the data (for provenance tracking)",
)
class DataTierEnum(EnumDefinitionImpl):
"""
Data quality/authority tier (from 04-data-standardization.md)
"""
TIER_1_AUTHORITATIVE = PermissibleValue(
text="TIER_1_AUTHORITATIVE",
description="Official registries (ISIL, national registers)")
TIER_2_VERIFIED = PermissibleValue(
text="TIER_2_VERIFIED",
description="Verified institutional data (website, official publications)")
TIER_3_CROWD_SOURCED = PermissibleValue(
text="TIER_3_CROWD_SOURCED",
description="Community-sourced data (Wikidata, OpenStreetMap)")
TIER_4_INFERRED = PermissibleValue(
text="TIER_4_INFERRED",
description="NLP-extracted or inferred data")
_defn = EnumDefinition(
name="DataTierEnum",
description="Data quality/authority tier (from 04-data-standardization.md)",
)
class MetadataStandardEnum(EnumDefinitionImpl):
"""
Metadata standards used by the institution
"""
DUBLIN_CORE = PermissibleValue(
text="DUBLIN_CORE",
description="Dublin Core Metadata Initiative",
meaning=DCTERMS["title"])
MARC21 = PermissibleValue(
text="MARC21",
description="MARC 21 bibliographic format")
EAD = PermissibleValue(
text="EAD",
description="Encoded Archival Description")
BIBFRAME = PermissibleValue(
text="BIBFRAME",
description="BIBFRAME bibliographic framework")
LIDO = PermissibleValue(
text="LIDO",
description="Lightweight Information Describing Objects (museum objects)")
CIDOC_CRM = PermissibleValue(
text="CIDOC_CRM",
description="CIDOC Conceptual Reference Model",
meaning=CRM["E1_CRM_Entity"])
SCHEMA_ORG = PermissibleValue(
text="SCHEMA_ORG",
description="Schema.org vocabulary",
meaning=SCHEMA["Thing"])
RIC_O = PermissibleValue(
text="RIC_O",
description="Records in Contexts Ontology",
meaning=RICO["Record"])
MODS = PermissibleValue(
text="MODS",
description="Metadata Object Description Schema")
PREMIS = PermissibleValue(
text="PREMIS",
description="PREservation Metadata Implementation Strategies")
SPECTRUM = PermissibleValue(
text="SPECTRUM",
description="UK museum collections management standard")
DACS = PermissibleValue(
text="DACS",
description="Describing Archives - A Content Standard")
_defn = EnumDefinition(
name="MetadataStandardEnum",
description="Metadata standards used by the institution",
)
class DigitalPlatformTypeEnum(EnumDefinitionImpl):
"""
Types of digital platforms used
"""
COLLECTION_MANAGEMENT = PermissibleValue(
text="COLLECTION_MANAGEMENT",
description="""Collection management system (CMS) or integrated library system (ILS). Examples: Koha, Alma, Symphony (libraries); Atlantis, MAIS, CollectiveAccess, TMS (museums/archives)""")
DIGITAL_REPOSITORY = PermissibleValue(
text="DIGITAL_REPOSITORY",
description="Digital repository (DSpace, EPrints)")
DISCOVERY_PORTAL = PermissibleValue(
text="DISCOVERY_PORTAL",
description="Discovery/search portal")
LINKED_DATA_ENDPOINT = PermissibleValue(
text="LINKED_DATA_ENDPOINT",
description="Linked Data/SPARQL endpoint")
API = PermissibleValue(
text="API",
description="Public API for data access")
AGGREGATOR = PermissibleValue(
text="AGGREGATOR",
description="Aggregation platform (Europeana, DPLA)")
WEBSITE = PermissibleValue(
text="WEBSITE",
description="Institutional website")
LEARNING_MANAGEMENT = PermissibleValue(
text="LEARNING_MANAGEMENT",
description="""Learning management systems for heritage education (Moodle, Google Classroom, Blackboard, Canvas)""",
meaning=SCHEMA["LearningResource"])
IDENTIFIER_SERVICE = PermissibleValue(
text="IDENTIFIER_SERVICE",
description="Persistent identifier assignment service (URN, DOI, Handle, ARK)",
meaning=SCHEMA["Service"])
GENERIC = PermissibleValue(
text="GENERIC",
description="""General-purpose software not specific to heritage sector. Examples: FileMaker, Microsoft Access, custom databases.""")
_defn = EnumDefinition(
name="DigitalPlatformTypeEnum",
description="Types of digital platforms used",
)
class ChangeTypeEnum(EnumDefinitionImpl):
"""
Types of organizational changes, based on TOOI Wijzigingsgebeurtenis patterns. Tracks major events in an
organization's lifecycle.
"""
FOUNDING = PermissibleValue(
text="FOUNDING",
description="Organization was founded or established",
meaning=TOOIONT["Oprichting"])
CLOSURE = PermissibleValue(
text="CLOSURE",
description="Organization ceased operations or was dissolved",
meaning=TOOIONT["Opheffing"])
MERGER = PermissibleValue(
text="MERGER",
description="Organization merged with one or more other organizations",
meaning=TOOIONT["Fusie"])
SPLIT = PermissibleValue(
text="SPLIT",
description="Organization split into multiple separate entities",
meaning=TOOIONT["Afsplitsing"])
ACQUISITION = PermissibleValue(
text="ACQUISITION",
description="Organization acquired another organization")
RELOCATION = PermissibleValue(
text="RELOCATION",
description="Organization moved to a new geographic location")
NAME_CHANGE = PermissibleValue(
text="NAME_CHANGE",
description="Organization changed its official name")
TYPE_CHANGE = PermissibleValue(
text="TYPE_CHANGE",
description="Institution type changed (e.g., archive became museum)")
STATUS_CHANGE = PermissibleValue(
text="STATUS_CHANGE",
description="Operational status changed")
RESTRUCTURING = PermissibleValue(
text="RESTRUCTURING",
description="Internal reorganization or structural change")
LEGAL_CHANGE = PermissibleValue(
text="LEGAL_CHANGE",
description="Change in legal status or governance")
OTHER = PermissibleValue(
text="OTHER",
description="Other type of organizational change")
_defn = EnumDefinition(
name="ChangeTypeEnum",
description="""Types of organizational changes, based on TOOI Wijzigingsgebeurtenis patterns. Tracks major events in an organization's lifecycle.""",
)
class EnrichmentTypeEnum(EnumDefinitionImpl):
"""
Types of data enrichment activities performed on heritage custodian records. Tracks what kind of data was added or
modified during enrichment processes.
"""
WIKIDATA_IDENTIFIER = PermissibleValue(
text="WIKIDATA_IDENTIFIER",
description="Wikidata Q-number identifier added via SPARQL query or API lookup",
meaning=PROV["Entity"])
GEOCODING = PermissibleValue(
text="GEOCODING",
description="Latitude/longitude coordinates added via geocoding service (Nominatim, GeoNames)",
meaning=PROV["Location"])
VIAF_IDENTIFIER = PermissibleValue(
text="VIAF_IDENTIFIER",
description="Virtual International Authority File (VIAF) identifier added",
meaning=PROV["Entity"])
ISIL_CODE = PermissibleValue(
text="ISIL_CODE",
description="International Standard Identifier for Libraries (ISIL) code assigned",
meaning=PROV["Entity"])
GHCID_GENERATION = PermissibleValue(
text="GHCID_GENERATION",
description="Global Heritage Custodian Identifier (GHCID) generated from institution metadata",
meaning=PROV["Entity"])
FALSE_POSITIVE_REMOVAL = PermissibleValue(
text="FALSE_POSITIVE_REMOVAL",
description="Incorrect or false positive enrichment data removed after verification",
meaning=PROV["Invalidation"])
NAME_NORMALIZATION = PermissibleValue(
text="NAME_NORMALIZATION",
description="Institution name normalized or standardized for consistency",
meaning=PROV["Revision"])
IDENTIFIER_VERIFICATION = PermissibleValue(
text="IDENTIFIER_VERIFICATION",
description="Existing identifier verified against authoritative source",
meaning=PROV["Validation"])
INSTITUTION_TYPE_CLASSIFICATION = PermissibleValue(
text="INSTITUTION_TYPE_CLASSIFICATION",
description="Institution type classified or corrected (GLAMORCUBESFIXPHDNT taxonomy)",
meaning=PROV["Revision"])
ADDRESS_STANDARDIZATION = PermissibleValue(
text="ADDRESS_STANDARDIZATION",
description="Physical address standardized or corrected using postal service data",
meaning=PROV["Revision"])
WEBSITE_URL_VALIDATION = PermissibleValue(
text="WEBSITE_URL_VALIDATION",
description="Institution website URL validated and updated",
meaning=PROV["Validation"])
COLLECTION_METADATA = PermissibleValue(
text="COLLECTION_METADATA",
description="Collection-level metadata added (extent, temporal coverage, subject areas)",
meaning=PROV["Entity"])
ORGANIZATIONAL_RELATIONSHIP = PermissibleValue(
text="ORGANIZATIONAL_RELATIONSHIP",
description="Relationship to parent/child organizations or networks identified",
meaning=PROV["Association"])
DIGITAL_PLATFORM_DETECTION = PermissibleValue(
text="DIGITAL_PLATFORM_DETECTION",
description="Digital platforms or systems used by institution identified",
meaning=PROV["Entity"])
OTHER = PermissibleValue(
text="OTHER",
description="Other type of enrichment activity not covered by standard types",
meaning=PROV["Activity"])
_defn = EnumDefinition(
name="EnrichmentTypeEnum",
description="""Types of data enrichment activities performed on heritage custodian records. Tracks what kind of data was added or modified during enrichment processes.""",
)
class PublicationTypeEnum(EnumDefinitionImpl):
"""
Types of scholarly publications
"""
JOURNAL_ARTICLE = PermissibleValue(
text="JOURNAL_ARTICLE",
description="Article published in an academic journal",
meaning=FABIO["JournalArticle"])
CONFERENCE_PAPER = PermissibleValue(
text="CONFERENCE_PAPER",
description="Paper presented at a conference",
meaning=FABIO["ConferencePaper"])
BOOK = PermissibleValue(
text="BOOK",
description="Scholarly book or monograph",
meaning=FABIO["Book"])
BOOK_CHAPTER = PermissibleValue(
text="BOOK_CHAPTER",
description="Chapter in an edited book",
meaning=FABIO["BookChapter"])
THESIS = PermissibleValue(
text="THESIS",
description="Thesis or dissertation",
meaning=FABIO["Thesis"])
TECHNICAL_REPORT = PermissibleValue(
text="TECHNICAL_REPORT",
description="Technical report or white paper",
meaning=FABIO["TechnicalReport"])
REVIEW_ARTICLE = PermissibleValue(
text="REVIEW_ARTICLE",
description="Review or survey article",
meaning=FABIO["ReviewArticle"])
EDITORIAL = PermissibleValue(
text="EDITORIAL",
description="Editorial or opinion piece",
meaning=FABIO["Editorial"])
PREPRINT = PermissibleValue(
text="PREPRINT",
description="Preprint or working paper",
meaning=FABIO["Preprint"])
DATASET = PermissibleValue(
text="DATASET",
description="Research dataset",
meaning=FABIO["Dataset"])
SOFTWARE = PermissibleValue(
text="SOFTWARE",
description="Software or code",
meaning=SCHEMA["SoftwareApplication"])
POSTER = PermissibleValue(
text="POSTER",
description="Conference poster",
meaning=FABIO["Poster"])
PRESENTATION = PermissibleValue(
text="PRESENTATION",
description="Presentation slides",
meaning=FABIO["Presentation"])
_defn = EnumDefinition(
name="PublicationTypeEnum",
description="Types of scholarly publications",
)
class CitationTypeEnum(EnumDefinitionImpl):
"""
Types of citation relationships (CiTO)
"""
CITES = PermissibleValue(
text="CITES",
description="Generic citation",
meaning=CITO["cites"])
CITES_AS_AUTHORITY = PermissibleValue(
text="CITES_AS_AUTHORITY",
description="Cites as authoritative source",
meaning=CITO["citesAsAuthority"])
CITES_AS_EVIDENCE = PermissibleValue(
text="CITES_AS_EVIDENCE",
description="Cites as evidence",
meaning=CITO["citesAsEvidence"])
CITES_AS_METADATA = PermissibleValue(
text="CITES_AS_METADATA",
description="Cites for metadata or provenance",
meaning=CITO["citesAsMetadataDocument"])
DISCUSSES = PermissibleValue(
text="DISCUSSES",
description="Discusses the cited work",
meaning=CITO["discusses"])
EXTENDS = PermissibleValue(
text="EXTENDS",
description="Extends the cited work",
meaning=CITO["extends"])
SUPPORTS = PermissibleValue(
text="SUPPORTS",
description="Provides support for claims in cited work",
meaning=CITO["supports"])
REFUTES = PermissibleValue(
text="REFUTES",
description="Refutes or disputes cited work",
meaning=CITO["disputes"])
CRITIQUES = PermissibleValue(
text="CRITIQUES",
description="Critiques cited work",
meaning=CITO["critiques"])
AGREES_WITH = PermissibleValue(
text="AGREES_WITH",
description="Agrees with cited work",
meaning=CITO["agreesWith"])
DISAGREES_WITH = PermissibleValue(
text="DISAGREES_WITH",
description="Disagrees with cited work",
meaning=CITO["disagreesWith"])
REVIEWS = PermissibleValue(
text="REVIEWS",
description="Reviews the cited work",
meaning=CITO["reviews"])
USES_METHOD_IN = PermissibleValue(
text="USES_METHOD_IN",
description="Uses methodology from cited work",
meaning=CITO["usesMethodIn"])
USES_DATA_FROM = PermissibleValue(
text="USES_DATA_FROM",
description="Uses data from cited work",
meaning=CITO["usesDataFrom"])
_defn = EnumDefinition(
name="CitationTypeEnum",
description="Types of citation relationships (CiTO)",
)
class OpenAccessStatusEnum(EnumDefinitionImpl):
"""
Open access availability status
"""
FULLY_OPEN_ACCESS = PermissibleValue(
text="FULLY_OPEN_ACCESS",
description="Freely available to all readers",
meaning=FABIO["OpenAccess"])
OPEN_ACCESS_REPOSITORY = PermissibleValue(
text="OPEN_ACCESS_REPOSITORY",
description="Available via institutional or subject repository",
meaning=FABIO["GreenOpenAccess"])
HYBRID_OPEN_ACCESS = PermissibleValue(
text="HYBRID_OPEN_ACCESS",
description="Published in subscription journal with OA option",
meaning=FABIO["HybridOpenAccess"])
CLOSED_ACCESS = PermissibleValue(
text="CLOSED_ACCESS",
description="Subscription or paywall access only",
meaning=FABIO["ClosedAccess"])
EMBARGOED = PermissibleValue(
text="EMBARGOED",
description="Will become open access after embargo period",
meaning=FABIO["EmbargoedAccess"])
BRONZE_OPEN_ACCESS = PermissibleValue(
text="BRONZE_OPEN_ACCESS",
description="Free to read but without clear license",
meaning=FABIO["BronzeOpenAccess"])
_defn = EnumDefinition(
name="OpenAccessStatusEnum",
description="Open access availability status",
)
class PublishingStatusEnum(EnumDefinitionImpl):
"""
Status in the publishing workflow (PSO)
"""
SUBMITTED = PermissibleValue(
text="SUBMITTED",
description="Submitted to journal/conference",
meaning=PSO["submitted"])
UNDER_REVIEW = PermissibleValue(
text="UNDER_REVIEW",
description="Under peer review",
meaning=PSO["under-review"])
ACCEPTED = PermissibleValue(
text="ACCEPTED",
description="Accepted for publication",
meaning=PSO["accepted"])
IN_PRESS = PermissibleValue(
text="IN_PRESS",
description="In press, awaiting publication",
meaning=PSO["in-press"])
PUBLISHED = PermissibleValue(
text="PUBLISHED",
description="Published and available",
meaning=PSO["published"])
REJECTED = PermissibleValue(
text="REJECTED",
description="Rejected by publisher",
meaning=PSO["rejected"])
WITHDRAWN = PermissibleValue(
text="WITHDRAWN",
description="Withdrawn by author(s)",
meaning=PSO["withdrawn"])
RETRACTED = PermissibleValue(
text="RETRACTED",
description="Retracted by publisher",
meaning=PSO["retracted"])
_defn = EnumDefinition(
name="PublishingStatusEnum",
description="Status in the publishing workflow (PSO)",
)
class DocumentSectionTypeEnum(EnumDefinitionImpl):
"""
Types of document sections (DoCO)
"""
ABSTRACT = PermissibleValue(
text="ABSTRACT",
description="Abstract or summary",
meaning=DOCO["Abstract"])
INTRODUCTION = PermissibleValue(
text="INTRODUCTION",
description="Introduction section",
meaning=DOCO["Introduction"])
METHODS = PermissibleValue(
text="METHODS",
description="Methods or methodology section",
meaning=DOCO["Methods"])
RESULTS = PermissibleValue(
text="RESULTS",
description="Results section",
meaning=DOCO["Results"])
DISCUSSION = PermissibleValue(
text="DISCUSSION",
description="Discussion section",
meaning=DOCO["Discussion"])
CONCLUSION = PermissibleValue(
text="CONCLUSION",
description="Conclusion section",
meaning=DOCO["Conclusion"])
ACKNOWLEDGMENTS = PermissibleValue(
text="ACKNOWLEDGMENTS",
description="Acknowledgments section",
meaning=DOCO["Acknowledgments"])
BIBLIOGRAPHY = PermissibleValue(
text="BIBLIOGRAPHY",
description="Bibliography or references",
meaning=DOCO["Bibliography"])
APPENDIX = PermissibleValue(
text="APPENDIX",
description="Appendix or supplementary material",
meaning=DOCO["Appendix"])
_defn = EnumDefinition(
name="DocumentSectionTypeEnum",
description="Types of document sections (DoCO)",
)
class PublishingRoleTypeEnum(EnumDefinitionImpl):
"""
Roles in the publishing process (PRO)
"""
AUTHOR = PermissibleValue(
text="AUTHOR",
description="Author of the work",
meaning=PRO["author"])
EDITOR = PermissibleValue(
text="EDITOR",
description="Editor",
meaning=PRO["editor"])
REVIEWER = PermissibleValue(
text="REVIEWER",
description="Peer reviewer",
meaning=PRO["reviewer"])
TRANSLATOR = PermissibleValue(
text="TRANSLATOR",
description="Translator",
meaning=PRO["translator"])
ILLUSTRATOR = PermissibleValue(
text="ILLUSTRATOR",
description="Illustrator",
meaning=PRO["illustrator"])
CONTRIBUTOR = PermissibleValue(
text="CONTRIBUTOR",
description="General contributor",
meaning=DCTERMS["contributor"])
CORRESPONDING_AUTHOR = PermissibleValue(
text="CORRESPONDING_AUTHOR",
description="Corresponding author",
meaning=PRO["corresponding-author"])
PUBLISHER = PermissibleValue(
text="PUBLISHER",
description="Publisher",
meaning=PRO["publisher"])
SERIES_EDITOR = PermissibleValue(
text="SERIES_EDITOR",
description="Series editor",
meaning=PRO["series-editor"])
_defn = EnumDefinition(
name="PublishingRoleTypeEnum",
description="Roles in the publishing process (PRO)",
)
# Slots
class slots:
pass
slots.id = Slot(uri=DCTERMS.identifier, name="id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.id, domain=None, range=URIRef)
slots.ghcid_numeric = Slot(uri=DCTERMS.identifier, name="ghcid_numeric", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.ghcid_numeric, domain=None, range=Optional[int])
slots.ghcid_current = Slot(uri=DCTERMS.identifier, name="ghcid_current", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.ghcid_current, domain=None, range=Optional[str],
pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$'))
slots.ghcid_original = Slot(uri=DCTERMS.identifier, name="ghcid_original", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.ghcid_original, domain=None, range=Optional[str],
pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$'))
slots.ghcid_history = Slot(uri=DCTERMS.provenance, name="ghcid_history", curie=DCTERMS.curie('provenance'),
model_uri=HERITAGE.ghcid_history, domain=None, range=Optional[Union[Union[dict, GHCIDHistoryEntry], list[Union[dict, GHCIDHistoryEntry]]]])
slots.record_id = Slot(uri=DCTERMS.identifier, name="record_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.record_id, domain=None, range=Optional[str],
pattern=re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$'))
slots.ghcid_uuid = Slot(uri=DCTERMS.identifier, name="ghcid_uuid", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.ghcid_uuid, domain=None, range=Optional[str],
pattern=re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$'))
slots.ghcid_uuid_sha256 = Slot(uri=DCTERMS.identifier, name="ghcid_uuid_sha256", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.ghcid_uuid_sha256, domain=None, range=Optional[str],
pattern=re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-8[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$'))
slots.name = Slot(uri=SCHEMA.name, name="name", curie=SCHEMA.curie('name'),
model_uri=HERITAGE.name, domain=None, range=str)
slots.alternative_names = Slot(uri=SCHEMA.alternateName, name="alternative_names", curie=SCHEMA.curie('alternateName'),
model_uri=HERITAGE.alternative_names, domain=None, range=Optional[Union[str, list[str]]])
slots.official_name = Slot(uri=TOOIONT.officieleNaamInclSoort, name="official_name", curie=TOOIONT.curie('officieleNaamInclSoort'),
model_uri=HERITAGE.official_name, domain=None, range=Optional[str])
slots.sorting_name = Slot(uri=TOOIONT.officieleNaamSorteer, name="sorting_name", curie=TOOIONT.curie('officieleNaamSorteer'),
model_uri=HERITAGE.sorting_name, domain=None, range=Optional[str])
slots.abbreviation = Slot(uri=TOOIONT.afkorting, name="abbreviation", curie=TOOIONT.curie('afkorting'),
model_uri=HERITAGE.abbreviation, domain=None, range=Optional[str])
slots.institution_type = Slot(uri=DCTERMS.type, name="institution_type", curie=DCTERMS.curie('type'),
model_uri=HERITAGE.institution_type, domain=None, range=Optional[Union[str, "InstitutionTypeEnum"]])
slots.organization_status = Slot(uri=ORG.organizationStatus, name="organization_status", curie=ORG.curie('organizationStatus'),
model_uri=HERITAGE.organization_status, domain=None, range=Optional[Union[str, "OrganizationStatusEnum"]])
slots.description = Slot(uri=DCTERMS.description, name="description", curie=DCTERMS.curie('description'),
model_uri=HERITAGE.description, domain=None, range=Optional[str])
slots.parent_organization = Slot(uri=ORG.subOrganizationOf, name="parent_organization", curie=ORG.curie('subOrganizationOf'),
model_uri=HERITAGE.parent_organization, domain=None, range=Optional[Union[str, HeritageCustodianId]])
slots.sub_organizations = Slot(uri=ORG.hasSubOrganization, name="sub_organizations", curie=ORG.curie('hasSubOrganization'),
model_uri=HERITAGE.sub_organizations, domain=None, range=Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]])
slots.founded_date = Slot(uri=SCHEMA.foundingDate, name="founded_date", curie=SCHEMA.curie('foundingDate'),
model_uri=HERITAGE.founded_date, domain=None, range=Optional[Union[str, XSDDate]])
slots.closed_date = Slot(uri=SCHEMA.dissolutionDate, name="closed_date", curie=SCHEMA.curie('dissolutionDate'),
model_uri=HERITAGE.closed_date, domain=None, range=Optional[Union[str, XSDDate]])
slots.prov_generated_at = Slot(uri=PROV.generatedAtTime, name="prov_generated_at", curie=PROV.curie('generatedAtTime'),
model_uri=HERITAGE.prov_generated_at, domain=None, range=Optional[Union[str, XSDDateTime]])
slots.prov_invalidated_at = Slot(uri=PROV.invalidatedAtTime, name="prov_invalidated_at", curie=PROV.curie('invalidatedAtTime'),
model_uri=HERITAGE.prov_invalidated_at, domain=None, range=Optional[Union[str, XSDDateTime]])
slots.change_history = Slot(uri=PROV.wasInfluencedBy, name="change_history", curie=PROV.curie('wasInfluencedBy'),
model_uri=HERITAGE.change_history, domain=None, range=Optional[Union[dict[Union[str, ChangeEventEventId], Union[dict, ChangeEvent]], list[Union[dict, ChangeEvent]]]])
slots.homepage = Slot(uri=FOAF.homepage, name="homepage", curie=FOAF.curie('homepage'),
model_uri=HERITAGE.homepage, domain=None, range=Optional[Union[str, URI]])
slots.contact_info = Slot(uri=HERITAGE.contact_info, name="contact_info", curie=HERITAGE.curie('contact_info'),
model_uri=HERITAGE.contact_info, domain=None, range=Optional[Union[dict, ContactInfo]])
slots.locations = Slot(uri=HERITAGE.locations, name="locations", curie=HERITAGE.curie('locations'),
model_uri=HERITAGE.locations, domain=None, range=Optional[Union[Union[dict, Location], list[Union[dict, Location]]]])
slots.identifiers = Slot(uri=HERITAGE.identifiers, name="identifiers", curie=HERITAGE.curie('identifiers'),
model_uri=HERITAGE.identifiers, domain=None, range=Optional[Union[Union[dict, Identifier], list[Union[dict, Identifier]]]])
slots.collections = Slot(uri=HERITAGE.collections, name="collections", curie=HERITAGE.curie('collections'),
model_uri=HERITAGE.collections, domain=None, range=Optional[Union[Union[dict, Collection], list[Union[dict, Collection]]]])
slots.digital_platforms = Slot(uri=HERITAGE.digital_platforms, name="digital_platforms", curie=HERITAGE.curie('digital_platforms'),
model_uri=HERITAGE.digital_platforms, domain=None, range=Optional[Union[Union[dict, DigitalPlatform], list[Union[dict, DigitalPlatform]]]])
slots.metadata_standards = Slot(uri=HERITAGE.metadata_standards, name="metadata_standards", curie=HERITAGE.curie('metadata_standards'),
model_uri=HERITAGE.metadata_standards, domain=None, range=Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]])
slots.partnerships = Slot(uri=HERITAGE.partnerships, name="partnerships", curie=HERITAGE.curie('partnerships'),
model_uri=HERITAGE.partnerships, domain=None, range=Optional[Union[Union[dict, Partnership], list[Union[dict, Partnership]]]])
slots.publications = Slot(uri=DCTERMS.bibliographicCitation, name="publications", curie=DCTERMS.curie('bibliographicCitation'),
model_uri=HERITAGE.publications, domain=None, range=Optional[Union[dict[Union[str, PublicationPublicationId], Union[dict, Publication]], list[Union[dict, Publication]]]])
slots.provenance = Slot(uri=HERITAGE.provenance, name="provenance", curie=HERITAGE.curie('provenance'),
model_uri=HERITAGE.provenance, domain=None, range=Union[dict, Provenance])
slots.location_type = Slot(uri=HERITAGE.location_type, name="location_type", curie=HERITAGE.curie('location_type'),
model_uri=HERITAGE.location_type, domain=None, range=Optional[str])
slots.street_address = Slot(uri=SCHEMA.streetAddress, name="street_address", curie=SCHEMA.curie('streetAddress'),
model_uri=HERITAGE.street_address, domain=None, range=Optional[str])
slots.city = Slot(uri=SCHEMA.addressLocality, name="city", curie=SCHEMA.curie('addressLocality'),
model_uri=HERITAGE.city, domain=None, range=Optional[str])
slots.postal_code = Slot(uri=SCHEMA.postalCode, name="postal_code", curie=SCHEMA.curie('postalCode'),
model_uri=HERITAGE.postal_code, domain=None, range=Optional[str])
slots.region = Slot(uri=SCHEMA.addressRegion, name="region", curie=SCHEMA.curie('addressRegion'),
model_uri=HERITAGE.region, domain=None, range=Optional[str])
slots.country = Slot(uri=SCHEMA.addressCountry, name="country", curie=SCHEMA.curie('addressCountry'),
model_uri=HERITAGE.country, domain=None, range=Optional[str],
pattern=re.compile(r'^[A-Z]{2}$'))
slots.latitude = Slot(uri=SCHEMA.latitude, name="latitude", curie=SCHEMA.curie('latitude'),
model_uri=HERITAGE.latitude, domain=None, range=Optional[float])
slots.longitude = Slot(uri=SCHEMA.longitude, name="longitude", curie=SCHEMA.curie('longitude'),
model_uri=HERITAGE.longitude, domain=None, range=Optional[float])
slots.geonames_id = Slot(uri=HERITAGE.geonames_id, name="geonames_id", curie=HERITAGE.curie('geonames_id'),
model_uri=HERITAGE.geonames_id, domain=None, range=Optional[str])
slots.is_primary = Slot(uri=HERITAGE.is_primary, name="is_primary", curie=HERITAGE.curie('is_primary'),
model_uri=HERITAGE.is_primary, domain=None, range=Optional[Union[bool, Bool]])
slots.email = Slot(uri=SCHEMA.email, name="email", curie=SCHEMA.curie('email'),
model_uri=HERITAGE.email, domain=None, range=Optional[str],
pattern=re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'))
slots.phone = Slot(uri=SCHEMA.telephone, name="phone", curie=SCHEMA.curie('telephone'),
model_uri=HERITAGE.phone, domain=None, range=Optional[str])
slots.fax = Slot(uri=SCHEMA.faxNumber, name="fax", curie=SCHEMA.curie('faxNumber'),
model_uri=HERITAGE.fax, domain=None, range=Optional[str])
slots.contact_type = Slot(uri=HERITAGE.contact_type, name="contact_type", curie=HERITAGE.curie('contact_type'),
model_uri=HERITAGE.contact_type, domain=None, range=Optional[str])
slots.identifier_scheme = Slot(uri=HERITAGE.identifier_scheme, name="identifier_scheme", curie=HERITAGE.curie('identifier_scheme'),
model_uri=HERITAGE.identifier_scheme, domain=None, range=Optional[str])
slots.identifier_value = Slot(uri=HERITAGE.identifier_value, name="identifier_value", curie=HERITAGE.curie('identifier_value'),
model_uri=HERITAGE.identifier_value, domain=None, range=Optional[str])
slots.identifier_url = Slot(uri=HERITAGE.identifier_url, name="identifier_url", curie=HERITAGE.curie('identifier_url'),
model_uri=HERITAGE.identifier_url, domain=None, range=Optional[Union[str, URI]])
slots.assigned_date = Slot(uri=HERITAGE.assigned_date, name="assigned_date", curie=HERITAGE.curie('assigned_date'),
model_uri=HERITAGE.assigned_date, domain=None, range=Optional[Union[str, XSDDate]])
slots.chamber_of_commerce_number = Slot(uri=DCTERMS.identifier, name="chamber_of_commerce_number", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.chamber_of_commerce_number, domain=None, range=Optional[str])
slots.municipality_identifier = Slot(uri=SCHEMA.addressLocality, name="municipality_identifier", curie=SCHEMA.curie('addressLocality'),
model_uri=HERITAGE.municipality_identifier, domain=None, range=Optional[str])
slots.parent_organization_name = Slot(uri=ORG.subOrganizationOf, name="parent_organization_name", curie=ORG.curie('subOrganizationOf'),
model_uri=HERITAGE.parent_organization_name, domain=None, range=Optional[str])
slots.unit_id = Slot(uri=DCTERMS.identifier, name="unit_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.unit_id, domain=None, range=URIRef)
slots.unit_name = Slot(uri=ORG.unitName, name="unit_name", curie=ORG.curie('unitName'),
model_uri=HERITAGE.unit_name, domain=None, range=str)
slots.unit_type = Slot(uri=ORG.classification, name="unit_type", curie=ORG.curie('classification'),
model_uri=HERITAGE.unit_type, domain=None, range=Optional[str])
slots.parent_unit = Slot(uri=ORG.unitOf, name="parent_unit", curie=ORG.curie('unitOf'),
model_uri=HERITAGE.parent_unit, domain=None, range=Optional[Union[str, OrganizationalUnitUnitId]])
slots.data_source = Slot(uri=HERITAGE.data_source, name="data_source", curie=HERITAGE.curie('data_source'),
model_uri=HERITAGE.data_source, domain=None, range=Union[str, "DataSourceEnum"])
slots.data_tier = Slot(uri=HERITAGE.data_tier, name="data_tier", curie=HERITAGE.curie('data_tier'),
model_uri=HERITAGE.data_tier, domain=None, range=Union[str, "DataTierEnum"])
slots.extraction_date = Slot(uri=HERITAGE.extraction_date, name="extraction_date", curie=HERITAGE.curie('extraction_date'),
model_uri=HERITAGE.extraction_date, domain=None, range=Union[str, XSDDateTime])
slots.extraction_method = Slot(uri=HERITAGE.extraction_method, name="extraction_method", curie=HERITAGE.curie('extraction_method'),
model_uri=HERITAGE.extraction_method, domain=None, range=Optional[str])
slots.confidence_score = Slot(uri=HERITAGE.confidence_score, name="confidence_score", curie=HERITAGE.curie('confidence_score'),
model_uri=HERITAGE.confidence_score, domain=None, range=Optional[float])
slots.conversation_id = Slot(uri=HERITAGE.conversation_id, name="conversation_id", curie=HERITAGE.curie('conversation_id'),
model_uri=HERITAGE.conversation_id, domain=None, range=Optional[str])
slots.source_url = Slot(uri=HERITAGE.source_url, name="source_url", curie=HERITAGE.curie('source_url'),
model_uri=HERITAGE.source_url, domain=None, range=Optional[Union[str, URI]])
slots.verified_date = Slot(uri=HERITAGE.verified_date, name="verified_date", curie=HERITAGE.curie('verified_date'),
model_uri=HERITAGE.verified_date, domain=None, range=Optional[Union[str, XSDDateTime]])
slots.verified_by = Slot(uri=HERITAGE.verified_by, name="verified_by", curie=HERITAGE.curie('verified_by'),
model_uri=HERITAGE.verified_by, domain=None, range=Optional[str])
slots.provenance_notes = Slot(uri=RDFS.comment, name="provenance_notes", curie=RDFS.curie('comment'),
model_uri=HERITAGE.provenance_notes, domain=None, range=Optional[str])
slots.ghcid = Slot(uri=HERITAGE.ghcid, name="ghcid", curie=HERITAGE.curie('ghcid'),
model_uri=HERITAGE.ghcid, domain=None, range=Optional[str],
pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$'))
slots.valid_from = Slot(uri=HERITAGE.valid_from, name="valid_from", curie=HERITAGE.curie('valid_from'),
model_uri=HERITAGE.valid_from, domain=None, range=Optional[Union[str, XSDDateTime]])
slots.valid_to = Slot(uri=HERITAGE.valid_to, name="valid_to", curie=HERITAGE.curie('valid_to'),
model_uri=HERITAGE.valid_to, domain=None, range=Optional[Union[str, XSDDateTime]])
slots.reason = Slot(uri=HERITAGE.reason, name="reason", curie=HERITAGE.curie('reason'),
model_uri=HERITAGE.reason, domain=None, range=Optional[str])
slots.institution_name = Slot(uri=HERITAGE.institution_name, name="institution_name", curie=HERITAGE.curie('institution_name'),
model_uri=HERITAGE.institution_name, domain=None, range=Optional[str])
slots.location_city = Slot(uri=HERITAGE.location_city, name="location_city", curie=HERITAGE.curie('location_city'),
model_uri=HERITAGE.location_city, domain=None, range=Optional[str])
slots.location_country = Slot(uri=HERITAGE.location_country, name="location_country", curie=HERITAGE.curie('location_country'),
model_uri=HERITAGE.location_country, domain=None, range=Optional[str])
slots.event_id = Slot(uri=DCTERMS.identifier, name="event_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.event_id, domain=None, range=URIRef)
slots.change_type = Slot(uri=RDF.type, name="change_type", curie=RDF.curie('type'),
model_uri=HERITAGE.change_type, domain=None, range=Union[str, "ChangeTypeEnum"])
slots.event_date = Slot(uri=PROV.atTime, name="event_date", curie=PROV.curie('atTime'),
model_uri=HERITAGE.event_date, domain=None, range=Union[str, XSDDate])
slots.event_description = Slot(uri=DCTERMS.description, name="event_description", curie=DCTERMS.curie('description'),
model_uri=HERITAGE.event_description, domain=None, range=Optional[str])
slots.affected_organization = Slot(uri=PROV.entity, name="affected_organization", curie=PROV.curie('entity'),
model_uri=HERITAGE.affected_organization, domain=None, range=Optional[Union[str, HeritageCustodianId]])
slots.resulting_organization = Slot(uri=PROV.generated, name="resulting_organization", curie=PROV.curie('generated'),
model_uri=HERITAGE.resulting_organization, domain=None, range=Optional[Union[str, HeritageCustodianId]])
slots.related_organizations = Slot(uri=PROV.wasAssociatedWith, name="related_organizations", curie=PROV.curie('wasAssociatedWith'),
model_uri=HERITAGE.related_organizations, domain=None, range=Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]])
slots.source_documentation = Slot(uri=DCTERMS.source, name="source_documentation", curie=DCTERMS.curie('source'),
model_uri=HERITAGE.source_documentation, domain=None, range=Optional[Union[str, URI]])
slots.enrichment_history = Slot(uri=HERITAGE.enrichment_history, name="enrichment_history", curie=HERITAGE.curie('enrichment_history'),
model_uri=HERITAGE.enrichment_history, domain=None, range=Optional[Union[Union[dict, EnrichmentHistoryEntry], list[Union[dict, EnrichmentHistoryEntry]]]])
slots.enrichment_date = Slot(uri=PROV.atTime, name="enrichment_date", curie=PROV.curie('atTime'),
model_uri=HERITAGE.enrichment_date, domain=None, range=Union[str, XSDDateTime])
slots.enrichment_method = Slot(uri=PROV.hadPlan, name="enrichment_method", curie=PROV.curie('hadPlan'),
model_uri=HERITAGE.enrichment_method, domain=None, range=str)
slots.enrichment_type = Slot(uri=RDF.type, name="enrichment_type", curie=RDF.curie('type'),
model_uri=HERITAGE.enrichment_type, domain=None, range=Union[str, "EnrichmentTypeEnum"])
slots.match_score = Slot(uri=ADMS.confidence, name="match_score", curie=ADMS.curie('confidence'),
model_uri=HERITAGE.match_score, domain=None, range=Optional[float])
slots.verified = Slot(uri=ADMS.status, name="verified", curie=ADMS.curie('status'),
model_uri=HERITAGE.verified, domain=None, range=Union[bool, Bool])
slots.enrichment_source = Slot(uri=DCTERMS.source, name="enrichment_source", curie=DCTERMS.curie('source'),
model_uri=HERITAGE.enrichment_source, domain=None, range=Optional[Union[str, URI]])
slots.enrichment_notes = Slot(uri=DCTERMS.description, name="enrichment_notes", curie=DCTERMS.curie('description'),
model_uri=HERITAGE.enrichment_notes, domain=None, range=Optional[str])
slots.collection_id = Slot(uri=HERITAGE.collection_id, name="collection_id", curie=HERITAGE.curie('collection_id'),
model_uri=HERITAGE.collection_id, domain=None, range=Optional[str])
slots.collection_name = Slot(uri=HERITAGE.collection_name, name="collection_name", curie=HERITAGE.curie('collection_name'),
model_uri=HERITAGE.collection_name, domain=None, range=Optional[str])
slots.collection_description = Slot(uri=DCTERMS.description, name="collection_description", curie=DCTERMS.curie('description'),
model_uri=HERITAGE.collection_description, domain=None, range=Optional[str])
slots.collection_type = Slot(uri=HERITAGE.collection_type, name="collection_type", curie=HERITAGE.curie('collection_type'),
model_uri=HERITAGE.collection_type, domain=None, range=Optional[str])
slots.item_count = Slot(uri=SCHEMA.size, name="item_count", curie=SCHEMA.curie('size'),
model_uri=HERITAGE.item_count, domain=None, range=Optional[str])
slots.subjects = Slot(uri=DCTERMS.subject, name="subjects", curie=DCTERMS.curie('subject'),
model_uri=HERITAGE.subjects, domain=None, range=Optional[Union[str, list[str]]])
slots.time_period_start = Slot(uri=HERITAGE.time_period_start, name="time_period_start", curie=HERITAGE.curie('time_period_start'),
model_uri=HERITAGE.time_period_start, domain=None, range=Optional[Union[str, XSDDate]])
slots.time_period_end = Slot(uri=HERITAGE.time_period_end, name="time_period_end", curie=HERITAGE.curie('time_period_end'),
model_uri=HERITAGE.time_period_end, domain=None, range=Optional[Union[str, XSDDate]])
slots.temporal_coverage = Slot(uri=DCTERMS.temporal, name="temporal_coverage", curie=DCTERMS.curie('temporal'),
model_uri=HERITAGE.temporal_coverage, domain=None, range=Optional[str],
pattern=re.compile(r'^\d{4}-\d{2}-\d{2}/\d{4}-\d{2}-\d{2}$'))
slots.access_rights = Slot(uri=HERITAGE.access_rights, name="access_rights", curie=HERITAGE.curie('access_rights'),
model_uri=HERITAGE.access_rights, domain=None, range=Optional[str])
slots.catalog_url = Slot(uri=HERITAGE.catalog_url, name="catalog_url", curie=HERITAGE.curie('catalog_url'),
model_uri=HERITAGE.catalog_url, domain=None, range=Optional[Union[str, URI]])
slots.custodian = Slot(uri=RICO.hasOrHadHolder, name="custodian", curie=RICO.curie('hasOrHadHolder'),
model_uri=HERITAGE.custodian, domain=None, range=Optional[Union[str, HeritageCustodianId]])
slots.platform_name = Slot(uri=HERITAGE.platform_name, name="platform_name", curie=HERITAGE.curie('platform_name'),
model_uri=HERITAGE.platform_name, domain=None, range=Optional[str])
slots.platform_type = Slot(uri=HERITAGE.platform_type, name="platform_type", curie=HERITAGE.curie('platform_type'),
model_uri=HERITAGE.platform_type, domain=None, range=Optional[Union[str, "DigitalPlatformTypeEnum"]])
slots.platform_url = Slot(uri=HERITAGE.platform_url, name="platform_url", curie=HERITAGE.curie('platform_url'),
model_uri=HERITAGE.platform_url, domain=None, range=Optional[Union[str, URI]])
slots.platform_description = Slot(uri=DCTERMS.description, name="platform_description", curie=DCTERMS.curie('description'),
model_uri=HERITAGE.platform_description, domain=None, range=Optional[str])
slots.vendor = Slot(uri=HERITAGE.vendor, name="vendor", curie=HERITAGE.curie('vendor'),
model_uri=HERITAGE.vendor, domain=None, range=Optional[str])
slots.implemented_standards = Slot(uri=HERITAGE.implemented_standards, name="implemented_standards", curie=HERITAGE.curie('implemented_standards'),
model_uri=HERITAGE.implemented_standards, domain=None, range=Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]])
slots.integration_method = Slot(uri=SCHEMA.applicationCategory, name="integration_method", curie=SCHEMA.curie('applicationCategory'),
model_uri=HERITAGE.integration_method, domain=None, range=Optional[str])
slots.partner_name = Slot(uri=HERITAGE.partner_name, name="partner_name", curie=HERITAGE.curie('partner_name'),
model_uri=HERITAGE.partner_name, domain=None, range=Optional[str])
slots.partner_id = Slot(uri=HERITAGE.partner_id, name="partner_id", curie=HERITAGE.curie('partner_id'),
model_uri=HERITAGE.partner_id, domain=None, range=Optional[Union[str, URIorCURIE]])
slots.partnership_type = Slot(uri=HERITAGE.partnership_type, name="partnership_type", curie=HERITAGE.curie('partnership_type'),
model_uri=HERITAGE.partnership_type, domain=None, range=Optional[str])
slots.start_date = Slot(uri=HERITAGE.start_date, name="start_date", curie=HERITAGE.curie('start_date'),
model_uri=HERITAGE.start_date, domain=None, range=Optional[Union[str, XSDDate]])
slots.end_date = Slot(uri=HERITAGE.end_date, name="end_date", curie=HERITAGE.curie('end_date'),
model_uri=HERITAGE.end_date, domain=None, range=Optional[Union[str, XSDDate]])
slots.kvk_number = Slot(uri=DCTERMS.identifier, name="kvk_number", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.kvk_number, domain=None, range=Optional[str],
pattern=re.compile(r'^[0-9]{8}$'))
slots.gemeente_code = Slot(uri=TOOIONT.gemeente, name="gemeente_code", curie=TOOIONT.curie('gemeente'),
model_uri=HERITAGE.gemeente_code, domain=None, range=Optional[str],
pattern=re.compile(r'^[0-9]{4}$'))
slots.work_id = Slot(uri=DCTERMS.identifier, name="work_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.work_id, domain=None, range=URIRef)
slots.work_title = Slot(uri=DCTERMS.title, name="work_title", curie=DCTERMS.curie('title'),
model_uri=HERITAGE.work_title, domain=None, range=Optional[str])
slots.work_subject = Slot(uri=DCTERMS.subject, name="work_subject", curie=DCTERMS.curie('subject'),
model_uri=HERITAGE.work_subject, domain=None, range=Optional[Union[str, list[str]]])
slots.work_keywords = Slot(uri=SCHEMA.keywords, name="work_keywords", curie=SCHEMA.curie('keywords'),
model_uri=HERITAGE.work_keywords, domain=None, range=Optional[Union[str, list[str]]])
slots.discipline = Slot(uri=HERITAGE.discipline, name="discipline", curie=HERITAGE.curie('discipline'),
model_uri=HERITAGE.discipline, domain=None, range=Optional[Union[str, list[str]]])
slots.research_field = Slot(uri=HERITAGE.research_field, name="research_field", curie=HERITAGE.curie('research_field'),
model_uri=HERITAGE.research_field, domain=None, range=Optional[Union[str, list[str]]])
slots.has_expression = Slot(uri=FRBR.realization, name="has_expression", curie=FRBR.curie('realization'),
model_uri=HERITAGE.has_expression, domain=None, range=Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]])
slots.related_institutions = Slot(uri=HERITAGE.related_institutions, name="related_institutions", curie=HERITAGE.curie('related_institutions'),
model_uri=HERITAGE.related_institutions, domain=None, range=Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]])
slots.publication_id = Slot(uri=DCTERMS.identifier, name="publication_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.publication_id, domain=None, range=URIRef)
slots.title = Slot(uri=DCTERMS.title, name="title", curie=DCTERMS.curie('title'),
model_uri=HERITAGE.title, domain=None, range=Optional[str])
slots.alternative_titles = Slot(uri=DCTERMS.alternative, name="alternative_titles", curie=DCTERMS.curie('alternative'),
model_uri=HERITAGE.alternative_titles, domain=None, range=Optional[Union[str, list[str]]])
slots.publication_type = Slot(uri=DCTERMS.type, name="publication_type", curie=DCTERMS.curie('type'),
model_uri=HERITAGE.publication_type, domain=None, range=Optional[Union[str, "PublicationTypeEnum"]])
slots.authors = Slot(uri=DCTERMS.creator, name="authors", curie=DCTERMS.curie('creator'),
model_uri=HERITAGE.authors, domain=None, range=Optional[Union[dict[Union[str, PersonPersonId], Union[dict, Person]], list[Union[dict, Person]]]])
slots.editors = Slot(uri=BIBO.editor, name="editors", curie=BIBO.curie('editor'),
model_uri=HERITAGE.editors, domain=None, range=Optional[Union[dict[Union[str, PersonPersonId], Union[dict, Person]], list[Union[dict, Person]]]])
slots.contributors = Slot(uri=DCTERMS.contributor, name="contributors", curie=DCTERMS.curie('contributor'),
model_uri=HERITAGE.contributors, domain=None, range=Optional[Union[dict[Union[str, PersonPersonId], Union[dict, Person]], list[Union[dict, Person]]]])
slots.publication_date = Slot(uri=DCTERMS.issued, name="publication_date", curie=DCTERMS.curie('issued'),
model_uri=HERITAGE.publication_date, domain=None, range=Optional[Union[str, XSDDate]])
slots.publication_year = Slot(uri=PRISM.publicationDate, name="publication_year", curie=PRISM.curie('publicationDate'),
model_uri=HERITAGE.publication_year, domain=None, range=Optional[int])
slots.abstract = Slot(uri=DCTERMS.abstract, name="abstract", curie=DCTERMS.curie('abstract'),
model_uri=HERITAGE.abstract, domain=None, range=Optional[str])
slots.keywords = Slot(uri=PRISM.keyword, name="keywords", curie=PRISM.curie('keyword'),
model_uri=HERITAGE.keywords, domain=None, range=Optional[Union[str, list[str]]])
slots.language = Slot(uri=DCTERMS.language, name="language", curie=DCTERMS.curie('language'),
model_uri=HERITAGE.language, domain=None, range=Optional[str])
slots.doi = Slot(uri=DATACITE.doi, name="doi", curie=DATACITE.curie('doi'),
model_uri=HERITAGE.doi, domain=None, range=Optional[str],
pattern=re.compile(r'^10\.\d{4,9}/[-._;()/:A-Za-z0-9]+$'))
slots.url = Slot(uri=SCHEMA.url, name="url", curie=SCHEMA.curie('url'),
model_uri=HERITAGE.url, domain=None, range=Optional[Union[str, URI]])
slots.published_in = Slot(uri=DCTERMS.isPartOf, name="published_in", curie=DCTERMS.curie('isPartOf'),
model_uri=HERITAGE.published_in, domain=None, range=Optional[Union[str, JournalJournalId]])
slots.volume = Slot(uri=PRISM.volume, name="volume", curie=PRISM.curie('volume'),
model_uri=HERITAGE.volume, domain=None, range=Optional[str])
slots.issue = Slot(uri=PRISM.number, name="issue", curie=PRISM.curie('number'),
model_uri=HERITAGE.issue, domain=None, range=Optional[str])
slots.page_range = Slot(uri=PRISM.pageRange, name="page_range", curie=PRISM.curie('pageRange'),
model_uri=HERITAGE.page_range, domain=None, range=Optional[str])
slots.article_number = Slot(uri=HERITAGE.article_number, name="article_number", curie=HERITAGE.curie('article_number'),
model_uri=HERITAGE.article_number, domain=None, range=Optional[str])
slots.publisher = Slot(uri=DCTERMS.publisher, name="publisher", curie=DCTERMS.curie('publisher'),
model_uri=HERITAGE.publisher, domain=None, range=Optional[Union[dict, Organization]])
slots.place_of_publication = Slot(uri=PRISM.location, name="place_of_publication", curie=PRISM.curie('location'),
model_uri=HERITAGE.place_of_publication, domain=None, range=Optional[str])
slots.isbn = Slot(uri=BIBO.isbn, name="isbn", curie=BIBO.curie('isbn'),
model_uri=HERITAGE.isbn, domain=None, range=Optional[str],
pattern=re.compile(r'^(97[89])?[0-9]{9}[0-9X]$'))
slots.issn = Slot(uri=BIBO.issn, name="issn", curie=BIBO.curie('issn'),
model_uri=HERITAGE.issn, domain=None, range=Optional[str],
pattern=re.compile(r'^\d{4}-\d{3}[\dX]$'))
slots.eissn = Slot(uri=FABIO.hasElectronicISSN, name="eissn", curie=FABIO.curie('hasElectronicISSN'),
model_uri=HERITAGE.eissn, domain=None, range=Optional[str],
pattern=re.compile(r'^\d{4}-\d{3}[\dX]$'))
slots.citations = Slot(uri=CITO.cites, name="citations", curie=CITO.curie('cites'),
model_uri=HERITAGE.citations, domain=None, range=Optional[Union[dict[Union[str, CitationCitationId], Union[dict, Citation]], list[Union[dict, Citation]]]])
slots.cited_by = Slot(uri=CITO.isCitedBy, name="cited_by", curie=CITO.curie('isCitedBy'),
model_uri=HERITAGE.cited_by, domain=None, range=Optional[Union[Union[str, CitationCitationId], list[Union[str, CitationCitationId]]]])
slots.related_works = Slot(uri=DCTERMS.relation, name="related_works", curie=DCTERMS.curie('relation'),
model_uri=HERITAGE.related_works, domain=None, range=Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]])
slots.document_sections = Slot(uri=HERITAGE.document_sections, name="document_sections", curie=HERITAGE.curie('document_sections'),
model_uri=HERITAGE.document_sections, domain=None, range=Optional[Union[dict[Union[str, DocumentSectionSectionId], Union[dict, DocumentSection]], list[Union[dict, DocumentSection]]]])
slots.open_access_status = Slot(uri=FABIO.hasOpenAccessStatus, name="open_access_status", curie=FABIO.curie('hasOpenAccessStatus'),
model_uri=HERITAGE.open_access_status, domain=None, range=Optional[Union[str, "OpenAccessStatusEnum"]])
slots.publishing_status = Slot(uri=PSO.holdsStatusInTime, name="publishing_status", curie=PSO.curie('holdsStatusInTime'),
model_uri=HERITAGE.publishing_status, domain=None, range=Optional[Union[str, "PublishingStatusEnum"]])
slots.peer_reviewed = Slot(uri=FABIO.hasPeerReviewStatus, name="peer_reviewed", curie=FABIO.curie('hasPeerReviewStatus'),
model_uri=HERITAGE.peer_reviewed, domain=None, range=Optional[Union[bool, Bool]])
slots.license = Slot(uri=DCTERMS.license, name="license", curie=DCTERMS.curie('license'),
model_uri=HERITAGE.license, domain=None, range=Optional[str])
slots.journal_id = Slot(uri=DCTERMS.identifier, name="journal_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.journal_id, domain=None, range=URIRef)
slots.journal_title = Slot(uri=DCTERMS.title, name="journal_title", curie=DCTERMS.curie('title'),
model_uri=HERITAGE.journal_title, domain=None, range=Optional[str])
slots.alternative_journal_titles = Slot(uri=DCTERMS.alternative, name="alternative_journal_titles", curie=DCTERMS.curie('alternative'),
model_uri=HERITAGE.alternative_journal_titles, domain=None, range=Optional[Union[str, list[str]]])
slots.journal_url = Slot(uri=SCHEMA.url, name="journal_url", curie=SCHEMA.curie('url'),
model_uri=HERITAGE.journal_url, domain=None, range=Optional[Union[str, URI]])
slots.impact_factor = Slot(uri=HERITAGE.impact_factor, name="impact_factor", curie=HERITAGE.curie('impact_factor'),
model_uri=HERITAGE.impact_factor, domain=None, range=Optional[float])
slots.cite_score = Slot(uri=HERITAGE.cite_score, name="cite_score", curie=HERITAGE.curie('cite_score'),
model_uri=HERITAGE.cite_score, domain=None, range=Optional[float])
slots.subject_areas = Slot(uri=DCTERMS.subject, name="subject_areas", curie=DCTERMS.curie('subject'),
model_uri=HERITAGE.subject_areas, domain=None, range=Optional[Union[str, list[str]]])
slots.indexing_services = Slot(uri=HERITAGE.indexing_services, name="indexing_services", curie=HERITAGE.curie('indexing_services'),
model_uri=HERITAGE.indexing_services, domain=None, range=Optional[Union[str, list[str]]])
slots.conference_id = Slot(uri=DCTERMS.identifier, name="conference_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.conference_id, domain=None, range=URIRef)
slots.conference_name = Slot(uri=SCHEMA.name, name="conference_name", curie=SCHEMA.curie('name'),
model_uri=HERITAGE.conference_name, domain=None, range=Optional[str])
slots.conference_acronym = Slot(uri=HERITAGE.conference_acronym, name="conference_acronym", curie=HERITAGE.curie('conference_acronym'),
model_uri=HERITAGE.conference_acronym, domain=None, range=Optional[str])
slots.conference_date = Slot(uri=SCHEMA.startDate, name="conference_date", curie=SCHEMA.curie('startDate'),
model_uri=HERITAGE.conference_date, domain=None, range=Optional[str])
slots.conference_location = Slot(uri=SCHEMA.location, name="conference_location", curie=SCHEMA.curie('location'),
model_uri=HERITAGE.conference_location, domain=None, range=Optional[str])
slots.conference_url = Slot(uri=SCHEMA.url, name="conference_url", curie=SCHEMA.curie('url'),
model_uri=HERITAGE.conference_url, domain=None, range=Optional[Union[str, URI]])
slots.proceedings_title = Slot(uri=HERITAGE.proceedings_title, name="proceedings_title", curie=HERITAGE.curie('proceedings_title'),
model_uri=HERITAGE.proceedings_title, domain=None, range=Optional[str])
slots.proceedings_isbn = Slot(uri=HERITAGE.proceedings_isbn, name="proceedings_isbn", curie=HERITAGE.curie('proceedings_isbn'),
model_uri=HERITAGE.proceedings_isbn, domain=None, range=Optional[str])
slots.proceedings_publisher = Slot(uri=HERITAGE.proceedings_publisher, name="proceedings_publisher", curie=HERITAGE.curie('proceedings_publisher'),
model_uri=HERITAGE.proceedings_publisher, domain=None, range=Optional[Union[dict, Organization]])
slots.person_id = Slot(uri=DCTERMS.identifier, name="person_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.person_id, domain=None, range=URIRef)
slots.person_name = Slot(uri=FOAF.name, name="person_name", curie=FOAF.curie('name'),
model_uri=HERITAGE.person_name, domain=None, range=Optional[str])
slots.given_name = Slot(uri=FOAF.givenName, name="given_name", curie=FOAF.curie('givenName'),
model_uri=HERITAGE.given_name, domain=None, range=Optional[str])
slots.family_name = Slot(uri=FOAF.familyName, name="family_name", curie=FOAF.curie('familyName'),
model_uri=HERITAGE.family_name, domain=None, range=Optional[str])
slots.orcid = Slot(uri=DATACITE.orcid, name="orcid", curie=DATACITE.curie('orcid'),
model_uri=HERITAGE.orcid, domain=None, range=Optional[str],
pattern=re.compile(r'^\d{4}-\d{4}-\d{4}-\d{3}[0-9X]$'))
slots.affiliation = Slot(uri=SCHEMA.affiliation, name="affiliation", curie=SCHEMA.curie('affiliation'),
model_uri=HERITAGE.affiliation, domain=None, range=Optional[Union[dict, Organization]])
slots.roles = Slot(uri=HERITAGE.roles, name="roles", curie=HERITAGE.curie('roles'),
model_uri=HERITAGE.roles, domain=None, range=Optional[Union[Union[dict, PublishingRole], list[Union[dict, PublishingRole]]]])
slots.organization_id = Slot(uri=DCTERMS.identifier, name="organization_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.organization_id, domain=None, range=URIRef)
slots.organization_name = Slot(uri=SCHEMA.name, name="organization_name", curie=SCHEMA.curie('name'),
model_uri=HERITAGE.organization_name, domain=None, range=Optional[str])
slots.organization_type = Slot(uri=SCHEMA.additionalType, name="organization_type", curie=SCHEMA.curie('additionalType'),
model_uri=HERITAGE.organization_type, domain=None, range=Optional[str])
slots.location = Slot(uri=SCHEMA.location, name="location", curie=SCHEMA.curie('location'),
model_uri=HERITAGE.location, domain=None, range=Optional[str])
slots.ror_id = Slot(uri=HERITAGE.ror_id, name="ror_id", curie=HERITAGE.curie('ror_id'),
model_uri=HERITAGE.ror_id, domain=None, range=Optional[str],
pattern=re.compile(r'^https://ror\.org/0[a-z0-9]{6}[0-9]{2}$'))
slots.citation_id = Slot(uri=DCTERMS.identifier, name="citation_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.citation_id, domain=None, range=URIRef)
slots.citing_work = Slot(uri=CITO.hasCitingEntity, name="citing_work", curie=CITO.curie('hasCitingEntity'),
model_uri=HERITAGE.citing_work, domain=None, range=Optional[Union[str, PublicationPublicationId]])
slots.cited_work = Slot(uri=CITO.hasCitedEntity, name="cited_work", curie=CITO.curie('hasCitedEntity'),
model_uri=HERITAGE.cited_work, domain=None, range=Optional[Union[str, PublicationPublicationId]])
slots.citation_type = Slot(uri=CITO.hasCitationCharacterization, name="citation_type", curie=CITO.curie('hasCitationCharacterization'),
model_uri=HERITAGE.citation_type, domain=None, range=Optional[Union[str, "CitationTypeEnum"]])
slots.citation_intent = Slot(uri=CITO.hasCitationIntent, name="citation_intent", curie=CITO.curie('hasCitationIntent'),
model_uri=HERITAGE.citation_intent, domain=None, range=Optional[str])
slots.citation_context = Slot(uri=HERITAGE.citation_context, name="citation_context", curie=HERITAGE.curie('citation_context'),
model_uri=HERITAGE.citation_context, domain=None, range=Optional[str])
slots.page_number = Slot(uri=HERITAGE.page_number, name="page_number", curie=HERITAGE.curie('page_number'),
model_uri=HERITAGE.page_number, domain=None, range=Optional[str])
slots.section_id = Slot(uri=DCTERMS.identifier, name="section_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.section_id, domain=None, range=URIRef)
slots.section_title = Slot(uri=DCTERMS.title, name="section_title", curie=DCTERMS.curie('title'),
model_uri=HERITAGE.section_title, domain=None, range=Optional[str])
slots.section_type = Slot(uri=DCTERMS.type, name="section_type", curie=DCTERMS.curie('type'),
model_uri=HERITAGE.section_type, domain=None, range=Optional[Union[str, "DocumentSectionTypeEnum"]])
slots.section_content = Slot(uri=HERITAGE.section_content, name="section_content", curie=HERITAGE.curie('section_content'),
model_uri=HERITAGE.section_content, domain=None, range=Optional[str])
slots.section_order = Slot(uri=HERITAGE.section_order, name="section_order", curie=HERITAGE.curie('section_order'),
model_uri=HERITAGE.section_order, domain=None, range=Optional[int])
slots.role_type = Slot(uri=PRO.withRole, name="role_type", curie=PRO.curie('withRole'),
model_uri=HERITAGE.role_type, domain=None, range=Optional[Union[str, "PublishingRoleTypeEnum"]])
slots.role_holder = Slot(uri=PRO.isHeldBy, name="role_holder", curie=PRO.curie('isHeldBy'),
model_uri=HERITAGE.role_holder, domain=None, range=Optional[Union[str, PersonPersonId]])
slots.role_context = Slot(uri=HERITAGE.role_context, name="role_context", curie=HERITAGE.curie('role_context'),
model_uri=HERITAGE.role_context, domain=None, range=Optional[str])
slots.HeritageCustodian_id = Slot(uri=DCTERMS.identifier, name="HeritageCustodian_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.HeritageCustodian_id, domain=HeritageCustodian, range=Union[str, HeritageCustodianId])
slots.HeritageCustodian_name = Slot(uri=SCHEMA.name, name="HeritageCustodian_name", curie=SCHEMA.curie('name'),
model_uri=HERITAGE.HeritageCustodian_name, domain=HeritageCustodian, range=str)
slots.HeritageCustodian_institution_type = Slot(uri=DCTERMS.type, name="HeritageCustodian_institution_type", curie=DCTERMS.curie('type'),
model_uri=HERITAGE.HeritageCustodian_institution_type, domain=HeritageCustodian, range=Union[str, "InstitutionTypeEnum"])
slots.Identifier_identifier_scheme = Slot(uri=HERITAGE.identifier_scheme, name="Identifier_identifier_scheme", curie=HERITAGE.curie('identifier_scheme'),
model_uri=HERITAGE.Identifier_identifier_scheme, domain=Identifier, range=str)
slots.Identifier_identifier_value = Slot(uri=HERITAGE.identifier_value, name="Identifier_identifier_value", curie=HERITAGE.curie('identifier_value'),
model_uri=HERITAGE.Identifier_identifier_value, domain=Identifier, range=str)
slots.OrganizationalUnit_unit_id = Slot(uri=DCTERMS.identifier, name="OrganizationalUnit_unit_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.OrganizationalUnit_unit_id, domain=OrganizationalUnit, range=Union[str, OrganizationalUnitUnitId])
slots.OrganizationalUnit_unit_name = Slot(uri=ORG.unitName, name="OrganizationalUnit_unit_name", curie=ORG.curie('unitName'),
model_uri=HERITAGE.OrganizationalUnit_unit_name, domain=OrganizationalUnit, range=str)
slots.EnrichmentHistoryEntry_enrichment_date = Slot(uri=PROV.atTime, name="EnrichmentHistoryEntry_enrichment_date", curie=PROV.curie('atTime'),
model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_date, domain=EnrichmentHistoryEntry, range=Union[str, XSDDateTime])
slots.EnrichmentHistoryEntry_enrichment_method = Slot(uri=PROV.hadPlan, name="EnrichmentHistoryEntry_enrichment_method", curie=PROV.curie('hadPlan'),
model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_method, domain=EnrichmentHistoryEntry, range=str)
slots.EnrichmentHistoryEntry_enrichment_type = Slot(uri=RDF.type, name="EnrichmentHistoryEntry_enrichment_type", curie=RDF.curie('type'),
model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_type, domain=EnrichmentHistoryEntry, range=Union[str, "EnrichmentTypeEnum"])
slots.EnrichmentHistoryEntry_match_score = Slot(uri=ADMS.confidence, name="EnrichmentHistoryEntry_match_score", curie=ADMS.curie('confidence'),
model_uri=HERITAGE.EnrichmentHistoryEntry_match_score, domain=EnrichmentHistoryEntry, range=Optional[float])
slots.EnrichmentHistoryEntry_verified = Slot(uri=ADMS.status, name="EnrichmentHistoryEntry_verified", curie=ADMS.curie('status'),
model_uri=HERITAGE.EnrichmentHistoryEntry_verified, domain=EnrichmentHistoryEntry, range=Union[bool, Bool])
slots.EnrichmentHistoryEntry_enrichment_source = Slot(uri=DCTERMS.source, name="EnrichmentHistoryEntry_enrichment_source", curie=DCTERMS.curie('source'),
model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_source, domain=EnrichmentHistoryEntry, range=Optional[Union[str, URI]])
slots.EnrichmentHistoryEntry_enrichment_notes = Slot(uri=DCTERMS.description, name="EnrichmentHistoryEntry_enrichment_notes", curie=DCTERMS.curie('description'),
model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_notes, domain=EnrichmentHistoryEntry, range=Optional[str])
slots.GHCIDHistoryEntry_ghcid = Slot(uri=HERITAGE.ghcid, name="GHCIDHistoryEntry_ghcid", curie=HERITAGE.curie('ghcid'),
model_uri=HERITAGE.GHCIDHistoryEntry_ghcid, domain=GHCIDHistoryEntry, range=str,
pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$'))
slots.GHCIDHistoryEntry_ghcid_numeric = Slot(uri=DCTERMS.identifier, name="GHCIDHistoryEntry_ghcid_numeric", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.GHCIDHistoryEntry_ghcid_numeric, domain=GHCIDHistoryEntry, range=int)
slots.GHCIDHistoryEntry_valid_from = Slot(uri=HERITAGE.valid_from, name="GHCIDHistoryEntry_valid_from", curie=HERITAGE.curie('valid_from'),
model_uri=HERITAGE.GHCIDHistoryEntry_valid_from, domain=GHCIDHistoryEntry, range=Union[str, XSDDateTime])
slots.GHCIDHistoryEntry_valid_to = Slot(uri=HERITAGE.valid_to, name="GHCIDHistoryEntry_valid_to", curie=HERITAGE.curie('valid_to'),
model_uri=HERITAGE.GHCIDHistoryEntry_valid_to, domain=GHCIDHistoryEntry, range=Optional[Union[str, XSDDateTime]])
slots.GHCIDHistoryEntry_reason = Slot(uri=HERITAGE.reason, name="GHCIDHistoryEntry_reason", curie=HERITAGE.curie('reason'),
model_uri=HERITAGE.GHCIDHistoryEntry_reason, domain=GHCIDHistoryEntry, range=str)
slots.GHCIDHistoryEntry_institution_name = Slot(uri=HERITAGE.institution_name, name="GHCIDHistoryEntry_institution_name", curie=HERITAGE.curie('institution_name'),
model_uri=HERITAGE.GHCIDHistoryEntry_institution_name, domain=GHCIDHistoryEntry, range=str)
slots.GHCIDHistoryEntry_location_city = Slot(uri=HERITAGE.location_city, name="GHCIDHistoryEntry_location_city", curie=HERITAGE.curie('location_city'),
model_uri=HERITAGE.GHCIDHistoryEntry_location_city, domain=GHCIDHistoryEntry, range=str)
slots.GHCIDHistoryEntry_location_country = Slot(uri=HERITAGE.location_country, name="GHCIDHistoryEntry_location_country", curie=HERITAGE.curie('location_country'),
model_uri=HERITAGE.GHCIDHistoryEntry_location_country, domain=GHCIDHistoryEntry, range=str)
slots.ChangeEvent_event_id = Slot(uri=DCTERMS.identifier, name="ChangeEvent_event_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.ChangeEvent_event_id, domain=ChangeEvent, range=Union[str, ChangeEventEventId])
slots.ChangeEvent_change_type = Slot(uri=RDF.type, name="ChangeEvent_change_type", curie=RDF.curie('type'),
model_uri=HERITAGE.ChangeEvent_change_type, domain=ChangeEvent, range=Union[str, "ChangeTypeEnum"])
slots.ChangeEvent_event_date = Slot(uri=PROV.atTime, name="ChangeEvent_event_date", curie=PROV.curie('atTime'),
model_uri=HERITAGE.ChangeEvent_event_date, domain=ChangeEvent, range=Union[str, XSDDate])
slots.DutchHeritageCustodian_identifiers = Slot(uri=HERITAGE.identifiers, name="DutchHeritageCustodian_identifiers", curie=HERITAGE.curie('identifiers'),
model_uri=HERITAGE.DutchHeritageCustodian_identifiers, domain=DutchHeritageCustodian, range=Optional[Union[Union[dict, Identifier], list[Union[dict, Identifier]]]])
slots.DutchHeritageCustodian_partnerships = Slot(uri=HERITAGE.partnerships, name="DutchHeritageCustodian_partnerships", curie=HERITAGE.curie('partnerships'),
model_uri=HERITAGE.DutchHeritageCustodian_partnerships, domain=DutchHeritageCustodian, range=Optional[Union[Union[dict, Partnership], list[Union[dict, Partnership]]]])
slots.DutchHeritageCustodian_locations = Slot(uri=HERITAGE.locations, name="DutchHeritageCustodian_locations", curie=HERITAGE.curie('locations'),
model_uri=HERITAGE.DutchHeritageCustodian_locations, domain=DutchHeritageCustodian, range=Optional[Union[Union[dict, Location], list[Union[dict, Location]]]])
slots.Publication_publication_id = Slot(uri=DCTERMS.identifier, name="Publication_publication_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.Publication_publication_id, domain=Publication, range=Union[str, PublicationPublicationId])
slots.Publication_title = Slot(uri=DCTERMS.title, name="Publication_title", curie=DCTERMS.curie('title'),
model_uri=HERITAGE.Publication_title, domain=Publication, range=str)
slots.Publication_publication_type = Slot(uri=DCTERMS.type, name="Publication_publication_type", curie=DCTERMS.curie('type'),
model_uri=HERITAGE.Publication_publication_type, domain=Publication, range=Union[str, "PublicationTypeEnum"])
slots.Journal_journal_id = Slot(uri=DCTERMS.identifier, name="Journal_journal_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.Journal_journal_id, domain=Journal, range=Union[str, JournalJournalId])
slots.Journal_journal_title = Slot(uri=DCTERMS.title, name="Journal_journal_title", curie=DCTERMS.curie('title'),
model_uri=HERITAGE.Journal_journal_title, domain=Journal, range=str)
slots.Conference_conference_id = Slot(uri=DCTERMS.identifier, name="Conference_conference_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.Conference_conference_id, domain=Conference, range=Union[str, ConferenceConferenceId])
slots.Conference_conference_name = Slot(uri=SCHEMA.name, name="Conference_conference_name", curie=SCHEMA.curie('name'),
model_uri=HERITAGE.Conference_conference_name, domain=Conference, range=str)
slots.Person_person_id = Slot(uri=DCTERMS.identifier, name="Person_person_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.Person_person_id, domain=Person, range=Union[str, PersonPersonId])
slots.Person_person_name = Slot(uri=FOAF.name, name="Person_person_name", curie=FOAF.curie('name'),
model_uri=HERITAGE.Person_person_name, domain=Person, range=str)
slots.Organization_organization_id = Slot(uri=DCTERMS.identifier, name="Organization_organization_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.Organization_organization_id, domain=Organization, range=Union[str, OrganizationOrganizationId])
slots.Organization_organization_name = Slot(uri=SCHEMA.name, name="Organization_organization_name", curie=SCHEMA.curie('name'),
model_uri=HERITAGE.Organization_organization_name, domain=Organization, range=str)
slots.Citation_citation_id = Slot(uri=DCTERMS.identifier, name="Citation_citation_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.Citation_citation_id, domain=Citation, range=Union[str, CitationCitationId])
slots.Citation_citing_work = Slot(uri=CITO.hasCitingEntity, name="Citation_citing_work", curie=CITO.curie('hasCitingEntity'),
model_uri=HERITAGE.Citation_citing_work, domain=Citation, range=Union[str, PublicationPublicationId])
slots.Citation_cited_work = Slot(uri=CITO.hasCitedEntity, name="Citation_cited_work", curie=CITO.curie('hasCitedEntity'),
model_uri=HERITAGE.Citation_cited_work, domain=Citation, range=Union[str, PublicationPublicationId])
slots.Citation_citation_type = Slot(uri=CITO.hasCitationCharacterization, name="Citation_citation_type", curie=CITO.curie('hasCitationCharacterization'),
model_uri=HERITAGE.Citation_citation_type, domain=Citation, range=Union[str, "CitationTypeEnum"])
slots.DocumentSection_section_id = Slot(uri=DCTERMS.identifier, name="DocumentSection_section_id", curie=DCTERMS.curie('identifier'),
model_uri=HERITAGE.DocumentSection_section_id, domain=DocumentSection, range=Union[str, DocumentSectionSectionId])
slots.PublishingRole_role_type = Slot(uri=PRO.withRole, name="PublishingRole_role_type", curie=PRO.curie('withRole'),
model_uri=HERITAGE.PublishingRole_role_type, domain=PublishingRole, range=Union[str, "PublishingRoleTypeEnum"])
slots.PublishingRole_role_holder = Slot(uri=PRO.isHeldBy, name="PublishingRole_role_holder", curie=PRO.curie('isHeldBy'),
model_uri=HERITAGE.PublishingRole_role_holder, domain=PublishingRole, range=Union[str, PersonPersonId])
# =============================================================================
# BACKWARD COMPATIBILITY ALIASES
# =============================================================================
# These aliases maintain backward compatibility with code that uses the old
# enum names without the "Enum" suffix. New code should use the full names.
# =============================================================================
# Enum aliases (old name -> new name)
InstitutionType = InstitutionTypeEnum
OrganizationStatus = OrganizationStatusEnum
DataSource = DataSourceEnum
DataTier = DataTierEnum
MetadataStandard = MetadataStandardEnum
DigitalPlatformType = DigitalPlatformTypeEnum
ChangeType = ChangeTypeEnum
EnrichmentType = EnrichmentTypeEnum
PublicationType = PublicationTypeEnum
CitationType = CitationTypeEnum
OpenAccessStatus = OpenAccessStatusEnum
PublishingStatus = PublishingStatusEnum
DocumentSectionType = DocumentSectionTypeEnum
PublishingRoleType = PublishingRoleTypeEnum
Reference in a new issue View git blame Copy permalink