linkml 1.8.7__py3-none-any.whl → 1.9.1rc2__py3-none-any.whl

linkml/utils/generator.py

@@ -20,10 +20,11 @@ import logging
 import os
 import re
 import sys
+from collections.abc import Mapping
 from dataclasses import dataclass, field
 from functools import lru_cache
 from pathlib import Path
-from typing import Callable, ClassVar, Dict, List, Mapping, Optional, Set, TextIO, Type, Union, cast
+from typing import Callable, ClassVar, Optional, TextIO, Union, cast
 
 import click
 from click import Argument, Command, Option
@@ -103,7 +104,7 @@ class Generator(metaclass=abc.ABCMeta):
     requires_metamodel: ClassVar[bool] = True
     """Generator queries an instance of the metamodel"""
 
-    valid_formats: ClassVar[List[str]] = []
+    valid_formats: ClassVar[list[str]] = []
     """Allowed formats - first format is default"""
 
     visit_all_class_slots: ClassVar[bool] = False
@@ -162,13 +163,13 @@ class Generator(metaclass=abc.ABCMeta):
     """Working directory or base URL of sources.
     Setting this is necessary for correct retrieval of relative imports."""
 
-    metamodel_name_map: Dict[str, str] = None
+    metamodel_name_map: dict[str, str] = None
     """Allows mapping of names of metamodel elements such as slot, etc"""
 
     importmap: Optional[Union[str, Optional[Mapping[str, str]]]] = None
     """File name of import mapping file -- maps import name/uri to target"""
 
-    emit_prefixes: Set[str] = field(default_factory=lambda: set())
+    emit_prefixes: set[str] = field(default_factory=lambda: set())
     """Prefixes to emit, for RDF-based generators"""
 
     metamodel: SchemaLoader = None
@@ -416,7 +417,7 @@ class Generator(metaclass=abc.ABCMeta):
     # =============================
     # Helper methods
     # =============================
-    def own_slots(self, cls: Union[ClassDefinitionName, ClassDefinition]) -> List[SlotDefinition]:
+    def own_slots(self, cls: Union[ClassDefinitionName, ClassDefinition]) -> list[SlotDefinition]:
         """Return the list of slots owned the class definition.  An "own slot" is any ``cls`` slot that does not appear
         in the class is_a parent.  Own_slots include:
 
@@ -442,7 +443,7 @@ class Generator(metaclass=abc.ABCMeta):
                 seen.add(sname_base)
         return sorted(rval, key=lambda s: s.name) if self.sort_class_slots else rval
 
-    def own_slot_names(self, cls: Union[ClassDefinitionName, ClassDefinition]) -> List[SlotDefinitionName]:
+    def own_slot_names(self, cls: Union[ClassDefinitionName, ClassDefinition]) -> list[SlotDefinitionName]:
         return [slot.name for slot in self.own_slots(cls)]
 
     def all_slots(
@@ -450,8 +451,8 @@ class Generator(metaclass=abc.ABCMeta):
         cls: Union[ClassDefinitionName, ClassDefinition],
         *,
         cls_slots_first: bool = False,
-        seen: Optional[Set[ClassDefinitionName]] = None,
-    ) -> List[SlotDefinition]:
+        seen: Optional[set[ClassDefinitionName]] = None,
+    ) -> list[SlotDefinition]:
         """Return all slots that are part of the class definition.  This includes all is_a, mixin and apply_to slots
         but does NOT include slot_usage targets.  If class B has a slot_usage entry for slot "s", only the slot
         definition for the redefined slot will be included, not its base.  Slots are added in the order they appear
@@ -499,7 +500,7 @@ class Generator(metaclass=abc.ABCMeta):
             )
         )
 
-    def ancestors(self, element: Union[ClassDefinition, SlotDefinition]) -> List[ElementName]:
+    def ancestors(self, element: Union[ClassDefinition, SlotDefinition]) -> list[ElementName]:
         """Return an ordered list of ancestor names for the supplied slot or class
 
         @param element: Slot or class name or definition
@@ -507,7 +508,7 @@ class Generator(metaclass=abc.ABCMeta):
         """
         return [element.name] + ([] if element.is_a is None else self.ancestors(self.parent(element)))
 
-    def neighborhood(self, elements: Union[str, ElementName, List[ElementName]]) -> References:
+    def neighborhood(self, elements: Union[str, ElementName, list[ElementName]]) -> References:
         """Return a list of all slots, classes and types that touch any element in elements, including the element
         itself
 
@@ -581,7 +582,7 @@ class Generator(metaclass=abc.ABCMeta):
 
         return touches
 
-    def range_type_path(self, typ: TypeDefinition) -> List[str]:
+    def range_type_path(self, typ: TypeDefinition) -> list[str]:
         """
         Return a formatted list of range types from the base up
 
@@ -618,14 +619,14 @@ class Generator(metaclass=abc.ABCMeta):
         return None
 
     @staticmethod
-    def enum_identifier_path(enum_or_enumname: Union[str, EnumDefinition]) -> List[str]:
+    def enum_identifier_path(enum_or_enumname: Union[str, EnumDefinition]) -> list[str]:
         """Return an enum_identifier path"""
         return [
             "str",
             camelcase(enum_or_enumname.name if isinstance(enum_or_enumname, EnumDefinition) else enum_or_enumname),
         ]
 
-    def class_identifier_path(self, cls_or_clsname: Union[str, ClassDefinition], force_non_key: bool) -> List[str]:
+    def class_identifier_path(self, cls_or_clsname: Union[str, ClassDefinition], force_non_key: bool) -> list[str]:
         """
         Return the path closure to a class identifier if the class has a key and force_non_key is false otherwise
         return a dictionary closure.
@@ -657,7 +658,7 @@ class Generator(metaclass=abc.ABCMeta):
                 return self.class_identifier_path(cls.is_a, False) + [pathname]
         return self.slot_range_path(identifier_slot) + [pathname]
 
-    def slot_range_path(self, slot_or_name: Union[str, SlotDefinition]) -> List[str]:
+    def slot_range_path(self, slot_or_name: Union[str, SlotDefinition]) -> list[str]:
         """
         Return an ordered list of slot ranges from distal to proximal
 
@@ -796,7 +797,7 @@ class Generator(metaclass=abc.ABCMeta):
             return self.schema.prefixes[PrefixPrefixPrefix(self.schema.default_prefix)].prefix_reference
 
     # TODO: add lru cache once we get identity into the classes
-    def domain_slots(self, cls: ClassDefinition) -> List[SlotDefinition]:
+    def domain_slots(self, cls: ClassDefinition) -> list[SlotDefinition]:
         """Return all slots in the class definition that are owned by the class"""
         domain_slots = []
         for slot_name in cls.slots:
@@ -912,7 +913,7 @@ class Generator(metaclass=abc.ABCMeta):
         return cls.class_uri == "linkml:Any"
 
 
-def shared_arguments(g: Type[Generator]) -> Callable[[Command], Command]:
+def shared_arguments(g: type[Generator]) -> Callable[[Command], Command]:
     def verbosity_callback(ctx, param, verbose):
         if verbose >= 2:
             logging.basicConfig(level=logging.DEBUG, force=True)

linkml/utils/helpers.py

@@ -1,6 +1,6 @@
 import re
 from functools import lru_cache
-from typing import List, Tuple, Union
+from typing import Union
 
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model.meta import (
@@ -28,7 +28,7 @@ def convert_to_snake_case(str):
 @lru_cache(None)
 def get_range_associated_slots(
     schemaview: SchemaView, range_class: ClassDefinition
-) -> Tuple[Union[SlotDefinition, None], Union[SlotDefinition, None], Union[List[SlotDefinition], None]]:
+) -> tuple[Union[SlotDefinition, None], Union[SlotDefinition, None], Union[list[SlotDefinition], None]]:
     if isinstance(range_class, ElementName):
         range_class = schemaview.get_class(range_class)
     if range_class is None:

linkml/utils/logictools.py

@@ -1,7 +1,8 @@
 import operator
+from collections.abc import Collection
 from copy import deepcopy
 from itertools import product
-from typing import Any, Collection, List, Optional, Tuple, Type
+from typing import Any, Optional
 
 
 def member_of(item: Any, collection: Collection[Any]) -> bool:
@@ -121,7 +122,7 @@ class And(Expression):
     """Conjunction of expressions"""
 
     def __init__(self, *operands: Expression):
-        self.operands: List[Expression] = list(operands)
+        self.operands: list[Expression] = list(operands)
 
     def __str__(self):
         return f'({" & ".join(str(operand) for operand in self.operands)})'
@@ -173,7 +174,7 @@ class Term(Expression):
 
 
 class IsIn(Term):
-    def __init__(self, element: Expression, collection: List[Any]):
+    def __init__(self, element: Expression, collection: list[Any]):
         self.predicate = "in"
         self.operands = [element, collection]
 
@@ -640,7 +641,7 @@ def _unsat(x: Expression, y: Expression) -> bool:
     return False
 
 
-def compose_operators(boolean_op: Type[Expression], op1: str, v1: Any, op2: str, v2: Any) -> Optional[Tuple]:
+def compose_operators(boolean_op: type[Expression], op1: str, v1: Any, op2: str, v2: Any) -> Optional[tuple]:
     """
     Compose two expressions.
 

linkml/utils/mergeutils.py

@@ -1,7 +1,10 @@
 import dataclasses
 import logging
+import os
 from copy import deepcopy
-from typing import Dict, List, Optional, Union, cast
+from pathlib import Path
+from typing import Optional, Union, cast
+from urllib.parse import urlparse
 
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
@@ -33,7 +36,7 @@ def merge_schemas(
     if target.license is None:
         target.license = mergee.license
 
-    target.imports += [imp for imp in mergee.imports if imp not in target.imports]
+    resolve_merged_imports(target, mergee, imported_from)
     set_from_schema(mergee)
 
     if namespaces:
@@ -125,8 +128,8 @@ def set_from_schema(schema: SchemaDefinition) -> None:
 
 
 def merge_dicts(
-    target: Dict[str, Element],
-    source: Dict[str, Element],
+    target: dict[str, Element],
+    source: dict[str, Element],
     imported_from: str,
     imported_from_uri: str,
     merge_imports: bool,
@@ -150,7 +153,7 @@ def merge_dicts(
 def merge_slots(
     target: Union[SlotDefinition, TypeDefinition],
     source: Union[SlotDefinition, TypeDefinition],
-    skip: List[Union[SlotDefinitionName, TypeDefinitionName]] = None,
+    skip: list[Union[SlotDefinitionName, TypeDefinitionName]] = None,
     inheriting: bool = True,
 ) -> None:
     """
@@ -232,3 +235,46 @@ def merge_enums(
     """
     # TODO: Finish enumeration merge code
     pass
+
+
+def resolve_merged_imports(
+    target: SchemaDefinition, mergee: SchemaDefinition, imported_from: Optional[str] = None
+) -> None:
+    """Merge the imports in source into target
+
+    :param target: Containing schema
+    :param mergee: mergee
+    :param imported_from: file that the mergee was imported from
+    :param at_end: True means add mergee to the end.  False to the front
+    """
+
+    for imp in mergee.imports:
+        if imp is None:
+            continue
+
+        # Skip if already imported
+        if imp in target.imports:
+            continue
+
+        # Leave as-is if the import has a scheme (e.g. http://)
+        elif urlparse(imp).scheme:
+            target.imports.append(imp)
+            continue
+
+        # Leave as-is if the import is an absolute path
+        elif Path(imp).is_absolute():
+            target.imports.append(imp)
+            continue
+
+        # Adjust relative imports to be relative to the importing file
+        elif imp.startswith("."):
+            if imported_from is None:
+                logger.warning(f"Cannot resolve relative import: {imp}")
+                target.imports.append(imp)
+            else:
+                resolved_imp = os.path.normpath(str(Path(imported_from).parent / Path(imp)))
+                target.imports.append(resolved_imp)
+
+        # By default, add the import as-is
+        else:
+            target.imports.append(imp)

linkml/utils/schema_builder.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from linkml_runtime.linkml_model import (
     ClassDefinition,
@@ -59,9 +59,9 @@ class SchemaBuilder:
 
     def add_class(
         self,
-        cls: Union[ClassDefinition, Dict, str],
-        slots: Union[Dict, List[Union[str, SlotDefinition]]] = None,
-        slot_usage: Union[Dict[str, SlotDefinition], Dict[str, Any], List[SlotDefinition]] = None,
+        cls: Union[ClassDefinition, dict, str],
+        slots: Union[dict, list[Union[str, SlotDefinition]]] = None,
+        slot_usage: Union[dict[str, SlotDefinition], dict[str, Any], list[SlotDefinition]] = None,
         replace_if_present=False,
         use_attributes=False,
         **kwargs,
@@ -125,7 +125,7 @@ class SchemaBuilder:
 
     def add_slot(
         self,
-        slot: Union[SlotDefinition, Dict, str],
+        slot: Union[SlotDefinition, dict, str],
         class_name: str = None,
         replace_if_present=False,
         **kwargs,
@@ -167,7 +167,7 @@ class SchemaBuilder:
     def add_enum(
         self,
         enum_def: Union[EnumDefinition, dict, str],
-        permissible_values: List[Union[str, PermissibleValue]] = None,
+        permissible_values: list[Union[str, PermissibleValue]] = None,
         replace_if_present=False,
         **kwargs,
     ) -> "SchemaBuilder":
@@ -232,7 +232,7 @@ class SchemaBuilder:
 
     def add_type(
         self,
-        type: Union[TypeDefinition, Dict, str],
+        type: Union[TypeDefinition, dict, str],
         typeof: str = None,
         uri: str = None,
         replace_if_present=False,
@@ -262,7 +262,7 @@ class SchemaBuilder:
             setattr(type, k, v)
         return self
 
-    def as_dict(self) -> Dict:
+    def as_dict(self) -> dict:
         """
         Returns the schema as a dictionary.
 

linkml/utils/schema_fixer.py

@@ -3,7 +3,7 @@ import re
 from collections import defaultdict
 from copy import copy
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Optional, Union
 
 import click
 import yaml
@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 pattern = re.compile(r"(?<!^)(?=[A-Z])")
 
 
-def yaml_rewrite(obj: Any, replacements: Dict[str, Any], include_keys=True) -> Any:
+def yaml_rewrite(obj: Any, replacements: dict[str, Any], include_keys=True) -> Any:
     if isinstance(obj, YAMLRoot):
         obj2 = copy(obj)
         for k, v in vars(obj).items():
@@ -52,7 +52,7 @@ class SchemaFixer:
     Multiple methods for adding additional information to schemas
     """
 
-    history: List[str] = None
+    history: list[str] = None
 
     def add_titles(self, schema: SchemaDefinition):
         """
@@ -111,7 +111,7 @@ class SchemaFixer:
         must_have_identifier=False,
         slot_name_func: Callable = None,
         convert_camel_case=False,
-    ) -> List[SlotDefinition]:
+    ) -> list[SlotDefinition]:
         """
         Adds index slots to a container pointing at all top-level classes
 
@@ -272,7 +272,7 @@ class SchemaFixer:
                 del cls.slot_usage[k]
 
     @staticmethod
-    def implicit_slots(schema: SchemaDefinition) -> Dict[str, Dict]:
+    def implicit_slots(schema: SchemaDefinition) -> dict[str, dict]:
         """
         Find slots that are implicit in the schema from slot_usage
 
@@ -317,11 +317,11 @@ class SchemaFixer:
     @staticmethod
     def fix_element_names(
         schema: SchemaDefinition,
-        schema_dict: Dict[str, Any] = None,
-        rules: Dict[str, Callable] = None,
+        schema_dict: dict[str, Any] = None,
+        rules: dict[str, Callable] = None,
         imports=False,
         preserve_original_using: Optional[str] = None,
-    ) -> Union[YAMLRoot, Dict]:
+    ) -> Union[YAMLRoot, dict]:
         """
         Changes element names to conform to naming conventions.
 

linkml/utils/schemaloader.py

@@ -1,9 +1,10 @@
 import logging
 import os
 from collections import OrderedDict
+from collections.abc import Iterator, Mapping
 from copy import deepcopy
 from pathlib import Path
-from typing import Dict, Iterator, List, Mapping, Optional, Set, TextIO, Tuple, Union, cast
+from typing import Optional, TextIO, Union, cast
 from urllib.parse import urlparse
 
 from jsonasobj2 import values
@@ -71,7 +72,7 @@ class SchemaLoader:
                 source_file_size=source_file_size,
             )
         # Map from URI to source and version tuple
-        self.loaded: OrderedDict[str, Tuple[str, str]] = {
+        self.loaded: OrderedDict[str, tuple[str, str]] = {
             self.schema.id: (self.schema.source_file, self.schema.version)
         }
         self.base_dir = self._get_base_dir(base_dir)
@@ -82,7 +83,7 @@ class SchemaLoader:
         self.source_file_size = source_file_size
         self.synopsis: Optional[SchemaSynopsis] = None
         self.schema_location: Optional[str] = None
-        self.schema_defaults: Dict[str, str] = {}  # Map from schema URI to default namespace
+        self.schema_defaults: dict[str, str] = {}  # Map from schema URI to default namespace
         self.merge_modules = mergeimports
         self.emit_metadata = emit_metadata
 
@@ -281,7 +282,7 @@ class SchemaLoader:
                     self.raise_value_error(f"Slot {slot.name}.inverse ({slot.inverse}) is not defined")
 
         # Update slots with parental information
-        merged_slots: List[SlotDefinitionName] = []
+        merged_slots: list[SlotDefinitionName] = []
         for slot in self.schema.slots.values():
             if not slot.from_schema:
                 slot.from_schema = self.schema.id
@@ -306,12 +307,12 @@ class SchemaLoader:
                 cls.from_schema = self.schema.id
 
         # Merge class with its mixins and the like
-        merged_classes: List[ClassDefinitionName] = []
+        merged_classes: list[ClassDefinitionName] = []
         for cls in self.schema.classes.values():
             self.merge_class(cls, merged_classes)
 
         # Update types with parental information
-        merged_types: List[TypeDefinitionName] = []
+        merged_types: list[TypeDefinitionName] = []
         for typ in self.schema.types.values():
             if not typ.base and not typ.typeof:
                 self.raise_value_error(
@@ -466,7 +467,7 @@ class SchemaLoader:
                     )
 
         # Check for duplicate class and type names
-        def check_dups(s1: Set[ElementName], s2: Set[ElementName]) -> Tuple[List[ElementName], str]:
+        def check_dups(s1: set[ElementName], s2: set[ElementName]) -> tuple[list[ElementName], str]:
             if s1.isdisjoint(s2):
                 return [], ""
 
@@ -616,13 +617,13 @@ class SchemaLoader:
                 self.raise_value_error(f"Subset: {subset} is not defined", subset)
         return self.schema
 
-    def validate_item_names(self, typ: str, names: List[str]) -> None:
+    def validate_item_names(self, typ: str, names: list[str]) -> None:
         # TODO: add a more rigorous syntax check for item names
         for name in names:
             if ":" in name:
                 raise self.raise_value_error(f'{typ}: "{name}" - ":" not allowed in identifier', name)
 
-    def merge_enum(self, enum: EnumDefinition, merged_enums: List[EnumDefinitionName]) -> None:
+    def merge_enum(self, enum: EnumDefinition, merged_enums: list[EnumDefinitionName]) -> None:
         """
         Merge parent enumeration information into target enum
 
@@ -641,7 +642,7 @@ class SchemaLoader:
                         enum.is_a,
                     )
 
-    def merge_slot(self, slot: SlotDefinition, merged_slots: List[SlotDefinitionName]) -> None:
+    def merge_slot(self, slot: SlotDefinition, merged_slots: list[SlotDefinitionName]) -> None:
         """
         Merge parent slot information into target slot
 
@@ -673,7 +674,7 @@ class SchemaLoader:
                     self.raise_value_error(f'Slot: "{slot.name}" - unknown mixin reference: {mixin}', mixin)
             merged_slots.append(slot.name)
 
-    def merge_class(self, cls: ClassDefinition, merged_classes: List[ClassDefinitionName]) -> None:
+    def merge_class(self, cls: ClassDefinition, merged_classes: list[ClassDefinitionName]) -> None:
         """
         Merge parent class information into target class
 
@@ -704,8 +705,8 @@ class SchemaLoader:
         Slot usages can be used to completely define slots.  Iterate over the class hierarchy finding all slot
         definitions that are introduced strictly as usages and add them to the slots component
         """
-        visited: Set[ClassDefinitionName] = set()
-        visited_usages: Set[SlotDefinitionName] = set()  # Slots that are or will be mangled
+        visited: set[ClassDefinitionName] = set()
+        visited_usages: set[SlotDefinitionName] = set()  # Slots that are or will be mangled
 
         def located_aliased_parent_slot(owning_class: ClassDefinition, usage_slot: SlotDefinition) -> bool:
             """Determine whether we are overriding an attributes style slot in the parent class
@@ -839,7 +840,7 @@ class SchemaLoader:
                         if new_val:
                             setattr(new_slot, metaslot_name, new_val)
 
-    def merge_type(self, typ: TypeDefinition, merged_types: List[TypeDefinitionName]) -> None:
+    def merge_type(self, typ: TypeDefinition, merged_types: list[TypeDefinitionName]) -> None:
         """
         Merge parent type information into target type
         :param typ: target type
@@ -858,7 +859,7 @@ class SchemaLoader:
                     )
             merged_types.append(typ.name)
 
-    def schema_errors(self) -> List[str]:
+    def schema_errors(self) -> list[str]:
         return self.synopsis.errors() if self.synopsis else ["resolve() must be run before error check"]
 
     def slot_definition_for(self, slotname: SlotDefinitionName, cls: ClassDefinition) -> Optional[SlotDefinition]:

linkml/utils/schemasynopsis.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Dict, List, Set, Union
+from typing import Union
 
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
@@ -36,45 +36,45 @@ class SchemaSynopsis:
     schema: SchemaDefinition = field(repr=False, compare=False)
 
     # References by type -- set by add_ref
-    typerefs: Dict[TypeDefinitionName, References] = empty_dict()  # Type name to all references
-    slotrefs: Dict[SlotDefinitionName, References] = empty_dict()  # Slot name to all references
-    classrefs: Dict[ClassDefinitionName, References] = empty_dict()  # Class name to all references
-    subsetrefs: Dict[SubsetDefinitionName, References] = empty_dict()  # Subset name to references
-    enumrefs: Dict[EnumDefinitionName, References] = empty_dict()  # Enum name to references
+    typerefs: dict[TypeDefinitionName, References] = empty_dict()  # Type name to all references
+    slotrefs: dict[SlotDefinitionName, References] = empty_dict()  # Slot name to all references
+    classrefs: dict[ClassDefinitionName, References] = empty_dict()  # Class name to all references
+    subsetrefs: dict[SubsetDefinitionName, References] = empty_dict()  # Subset name to references
+    enumrefs: dict[EnumDefinitionName, References] = empty_dict()  # Enum name to references
 
     # Type specific
-    typebases: Dict[str, Set[TypeDefinitionName]] = empty_dict()  # Base referencing types (direct and indirect)
-    typeofs: Dict[TypeDefinitionName, TypeDefinitionName] = empty_dict()  # Type to specializations
+    typebases: dict[str, set[TypeDefinitionName]] = empty_dict()  # Base referencing types (direct and indirect)
+    typeofs: dict[TypeDefinitionName, TypeDefinitionName] = empty_dict()  # Type to specializations
 
     # Slot specific
-    slotclasses: Dict[SlotDefinitionName, Set[ClassDefinitionName]] = empty_dict()  # Slot to including classes
-    definingslots: Dict[SlotDefinitionName, Set[ClassDefinitionName]] = empty_dict()  # Slot to defining decls
-    slotusages: Dict[SlotDefinitionName, Set[ClassDefinitionName]] = empty_dict()  # Slot to overriding classes
-    owners: Dict[SlotDefinitionName, Set[ClassDefinitionName]] = empty_dict()  # Slot to owning classes (sb. 1)
-    inverses: Dict[str, Set[str]] = empty_dict()  # Slots declared as inverses of other slots
+    slotclasses: dict[SlotDefinitionName, set[ClassDefinitionName]] = empty_dict()  # Slot to including classes
+    definingslots: dict[SlotDefinitionName, set[ClassDefinitionName]] = empty_dict()  # Slot to defining decls
+    slotusages: dict[SlotDefinitionName, set[ClassDefinitionName]] = empty_dict()  # Slot to overriding classes
+    owners: dict[SlotDefinitionName, set[ClassDefinitionName]] = empty_dict()  # Slot to owning classes (sb. 1)
+    inverses: dict[str, set[str]] = empty_dict()  # Slots declared as inverses of other slots
 
     # Class specific
-    ownslots: Dict[ClassDefinitionName, Set[SlotDefinitionName]] = empty_dict()  # Slots directly owned by class
+    ownslots: dict[ClassDefinitionName, set[SlotDefinitionName]] = empty_dict()  # Slots directly owned by class
 
     # Enum specific
-    codesets: Dict[URIRef, Set[EnumDefinitionName]] = empty_dict()  # Code set URI to enumeration definition
+    codesets: dict[URIRef, set[EnumDefinitionName]] = empty_dict()  # Code set URI to enumeration definition
 
     # Class to slot domains == class.slots
 
     # Slot or Class (Definition) specific
     roots: References = empty_references()  # Definitions with no parents
-    isarefs: Dict[DefinitionName, References] = empty_dict()  # Definition to isa references
-    mixinrefs: Dict[DefinitionName, References] = empty_dict()  # Mixin to referencing classes or slots
+    isarefs: dict[DefinitionName, References] = empty_dict()  # Definition to isa references
+    mixinrefs: dict[DefinitionName, References] = empty_dict()  # Mixin to referencing classes or slots
     mixins: References = empty_references()  # Definitions declared as mixin
     abstracts: References = empty_references()  # Definitions declared as abstract
     applytos: References = empty_references()  # Definitions that include applytos
-    applytorefs: Dict[DefinitionName, References] = empty_dict()  # Definition to applyier
+    applytorefs: dict[DefinitionName, References] = empty_dict()  # Definition to applyier
 
     # Slot or Type specific
-    rangerefs: Dict[ElementName, Set[SlotDefinitionName]] = empty_dict()  # Type or class to range slot
+    rangerefs: dict[ElementName, set[SlotDefinitionName]] = empty_dict()  # Type or class to range slot
 
     # Element - any type
-    inschema: Dict[str, References] = empty_references()  # Schema name to elements
+    inschema: dict[str, References] = empty_references()  # Schema name to elements
 
     def __post_init__(self):
         for k, v in self.schema.slots.items():
@@ -237,8 +237,8 @@ class SchemaSynopsis:
     def _ancestor_is_owned(self, slot: SlotDefinition) -> bool:
         return bool(slot.is_a) and (slot.is_a in self.owners or self._ancestor_is_owned(self.schema.slots[slot.is_a]))
 
-    def errors(self) -> List[str]:
-        def format_undefineds(refs: Set[Union[str, TypedNode]]) -> List[str]:
+    def errors(self) -> list[str]:
+        def format_undefineds(refs: set[Union[str, TypedNode]]) -> list[str]:
             return [f"{TypedNode.yaml_loc(ref)}: {ref}" for ref in refs]
 
         rval = []
@@ -266,7 +266,7 @@ class SchemaSynopsis:
         return rval
 
     def summary(self) -> str:
-        def summarize_refs(refs: Dict[ElementName, References]) -> str:
+        def summarize_refs(refs: dict[ElementName, References]) -> str:
             clsrefs, slotrefs, typerefs, enumrefs = set(), set(), set(), set()
             if refs is not None:
                 for cr in refs.values():
@@ -279,7 +279,7 @@ class SchemaSynopsis:
                 f"{len(typerefs)} types, {len(enumrefs)} enums "
             )
 
-        def recurse_types(typ: TypeDefinitionName, indent: str = "\t\t\t") -> List[str]:
+        def recurse_types(typ: TypeDefinitionName, indent: str = "\t\t\t") -> list[str]:
             rval = [f"{indent}{typ}" + (":" if typ in self.typeofs else "")]
             if typ in sorted(self.typeofs):
                 for tr in sorted(self.typeofs[typ]):
@@ -332,7 +332,7 @@ class SchemaSynopsis:
 
         # Slots that are defined but do not (directly) occur in any class
         n_unreferenced_descendants: int = 0
-        unowned_slots: Set[SlotDefinitionName] = set()
+        unowned_slots: set[SlotDefinitionName] = set()
         for slotname, slot in sorted(self.schema.slots.items(), key=lambda e: e[0]):
             if slotname not in self.owners:
                 if slot.domain:
@@ -345,10 +345,10 @@ class SchemaSynopsis:
         if unowned_slots:
             rval += [f"\t* Unowned slots: {', '.join(sorted(unowned_slots))}"]
 
-        not_in_domain: Set[SlotDefinitionName] = set()
-        domain_mismatches: Set[SlotDefinitionName] = set()
-        unkdomains: Set[SlotDefinitionName] = set()
-        emptydomains: Set[SlotDefinitionName] = set()
+        not_in_domain: set[SlotDefinitionName] = set()
+        domain_mismatches: set[SlotDefinitionName] = set()
+        unkdomains: set[SlotDefinitionName] = set()
+        emptydomains: set[SlotDefinitionName] = set()
 
         for slot in self.schema.slots.values():
             if not slot.domain: