linkml 1.9.0rc1__py3-none-any.whl → 1.9.1rc3__py3-none-any.whl

linkml/generators/pydanticgen/pydanticgen.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import ClassVar, Dict, List, Literal, Optional, Set, Tuple, Type, TypeVar, Union, overload
+from typing import ClassVar, Literal, Optional, TypeVar, Union, overload
 
 import click
 from jinja2 import ChoiceLoader, Environment, FileSystemLoader, Template
@@ -82,9 +82,7 @@ DEFAULT_IMPORTS = (
         objects=[
             ObjectImport(name="Any"),
             ObjectImport(name="ClassVar"),
-            ObjectImport(name="List"),
             ObjectImport(name="Literal"),
-            ObjectImport(name="Dict"),
             ObjectImport(name="Optional"),
             ObjectImport(name="Union"),
         ],
@@ -183,7 +181,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     file_extension = "py"
 
     # ObjectVars
-    array_representations: List[ArrayRepresentation] = field(default_factory=lambda: [ArrayRepresentation.LIST])
+    array_representations: list[ArrayRepresentation] = field(default_factory=lambda: [ArrayRepresentation.LIST])
     black: bool = False
     """
     If black is present in the environment, format the serialized code with it
@@ -199,7 +197,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     """
     extra_fields: Literal["allow", "forbid", "ignore"] = "forbid"
     gen_mixin_inheritance: bool = True
-    injected_classes: Optional[List[Union[Type, str]]] = None
+    injected_classes: Optional[list[Union[type, str]]] = None
     """
     A list/tuple of classes to inject into the generated module.
 
@@ -208,7 +206,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     source file (ie. the module they are contained in needs a ``__file__`` attr,
     see: :func:`inspect.getsource` )
     """
-    injected_fields: Optional[List[str]] = None
+    injected_fields: Optional[list[str]] = None
     """
     A list/tuple of field strings to inject into the base class.
 
@@ -221,7 +219,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         )
 
     """
-    imports: Optional[Union[List[Import], Imports]] = None
+    imports: Optional[Union[list[Import], Imports]] = None
     """
     Additional imports to inject into generated module.
 
@@ -353,8 +351,8 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     """Substitute CamelCase and non-word characters with _"""
 
     # Private attributes
-    _predefined_slot_values: Optional[Dict[str, Dict[str, str]]] = None
-    _class_bases: Optional[Dict[str, List[str]]] = None
+    _predefined_slot_values: Optional[dict[str, dict[str, str]]] = None
+    _class_bases: Optional[dict[str, list[str]]] = None
 
     def __post_init__(self):
         super().__post_init__()
@@ -372,7 +370,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             logger.error(f"Error compiling generated python code: {e}")
             raise e
 
-    def _get_classes(self, sv: SchemaView) -> Tuple[List[ClassDefinition], Optional[List[ClassDefinition]]]:
+    def _get_classes(self, sv: SchemaView) -> tuple[list[ClassDefinition], Optional[list[ClassDefinition]]]:
         all_classes = sv.all_classes(imports=True).values()
 
         if self.split:
@@ -384,8 +382,8 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
 
     @staticmethod
     def sort_classes(
-        clist: List[ClassDefinition], imported: Optional[List[ClassDefinition]] = None
-    ) -> List[ClassDefinition]:
+        clist: list[ClassDefinition], imported: Optional[list[ClassDefinition]] = None
+    ) -> list[ClassDefinition]:
         """
         sort classes such that if C is a child of P then C appears after P in the list
 
@@ -515,7 +513,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             else:
                 collection_key = None
             if slot.inlined is False or collection_key is None or slot.inlined_as_list is True:
-                result.attribute.range = f"List[{result.attribute.range}]"
+                result.attribute.range = f"list[{result.attribute.range}]"
             else:
                 simple_dict_value = None
                 if len(slot_ranges) == 1:
@@ -525,15 +523,15 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
                     # so we specify either that identifier or the range itself
                     if simple_dict_value != result.attribute.range:
                         simple_dict_value = f"Union[{simple_dict_value}, {result.attribute.range}]"
-                    result.attribute.range = f"Dict[str, {simple_dict_value}]"
+                    result.attribute.range = f"dict[str, {simple_dict_value}]"
                 else:
-                    result.attribute.range = f"Dict[{collection_key}, {result.attribute.range}]"
+                    result.attribute.range = f"dict[{collection_key}, {result.attribute.range}]"
         if not (slot.required or slot.identifier or slot.key) and not slot.designates_type:
             result.attribute.range = f"Optional[{result.attribute.range}]"
         return result
 
     @property
-    def predefined_slot_values(self) -> Dict[str, Dict[str, str]]:
+    def predefined_slot_values(self) -> dict[str, dict[str, str]]:
         """
         :return: Dictionary of dictionaries with predefined slot values for each class
         """
@@ -563,7 +561,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         return self._predefined_slot_values
 
     @property
-    def class_bases(self) -> Dict[str, List[str]]:
+    def class_bases(self) -> dict[str, list[str]]:
         """
         Generate the inheritance list for each class from is_a plus mixins
         :return:
@@ -682,7 +680,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
 
     def generate_collection_key(
         self,
-        slot_ranges: List[str],
+        slot_ranges: list[str],
         slot_def: SlotDefinition,
         class_def: ClassDefinition,
     ) -> Optional[str]:
@@ -697,7 +695,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         :param slot_ranges: list of python range values
         """
 
-        collection_keys: Set[str] = set()
+        collection_keys: set[str] = set()
 
         if slot_ranges is None:
             return None
@@ -715,7 +713,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             return list(collection_keys)[0]
         return None
 
-    def _clean_injected_classes(self, injected_classes: List[Union[str, Type]]) -> Optional[List[str]]:
+    def _clean_injected_classes(self, injected_classes: list[Union[str, type]]) -> Optional[list[str]]:
         """Get source, deduplicate, and dedent injected classes"""
         if len(injected_classes) == 0:
             return None
@@ -769,7 +767,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             env.loader = loader
         return env
 
-    def get_array_representations_range(self, slot: SlotDefinition, range: str) -> List[SlotResult]:
+    def get_array_representations_range(self, slot: SlotDefinition, range: str) -> list[SlotResult]:
         """
         Generate the python range for array representations
         """
@@ -1028,7 +1026,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         split_context: Optional[dict] = None,
         split_mode: SplitMode = SplitMode.AUTO,
         **kwargs,
-    ) -> List[SplitResult]:
+    ) -> list[SplitResult]:
         """
         Generate a schema that imports from other schema as a set of python modules that
         import from one another, rather than generating all imported classes in a single schema.
@@ -1119,7 +1117,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         return results
 
 
-def _subclasses(cls: Type):
+def _subclasses(cls: type):
     return set(cls.__subclasses__()).union([s for c in cls.__subclasses__() for s in _subclasses(c)])
 
 
@@ -1137,7 +1135,7 @@ def _import_to_path(module: str) -> Path:
     return Path(*dir_pieces)
 
 
-def _ensure_inits(paths: List[Path]):
+def _ensure_inits(paths: list[Path]):
     """For a set of paths, find the common root and it and all the subdirectories have an __init__.py"""
     # if there is only one file, there is no relative importing to be done
     if len(paths) <= 1:
@@ -1223,10 +1221,8 @@ def cli(
     """Generate pydantic classes to represent a LinkML model"""
     if template_file is not None:
         raise DeprecationWarning(
-            (
-                "Passing a single template_file is deprecated. Pass a directory of template files instead. "
-                "See help string for --template-dir"
-            )
+            "Passing a single template_file is deprecated. Pass a directory of template files instead. "
+            "See help string for --template-dir"
         )
 
     if template_dir is not None:

linkml/generators/pydanticgen/template.py

@@ -1,6 +1,7 @@
 import sys
+from collections.abc import Generator
 from importlib.util import find_spec
-from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Tuple, Union, get_args
+from typing import Any, ClassVar, Literal, Optional, Union, get_args
 
 from jinja2 import Environment, PackageLoader
 from pydantic import BaseModel, Field, field_validator
@@ -74,7 +75,7 @@ class PydanticTemplateModel(TemplateModel):
         loader=PackageLoader("linkml.generators.pydanticgen", "templates"), trim_blocks=True, lstrip_blocks=True
     )
 
-    meta_exclude: ClassVar[List[str]] = None
+    meta_exclude: ClassVar[list[str]] = None
 
     def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
         """
@@ -125,7 +126,7 @@ class PydanticEnum(PydanticTemplateModel):
 
     name: str
     description: Optional[str] = None
-    values: Dict[str, EnumValue] = Field(default_factory=dict)
+    values: dict[str, EnumValue] = Field(default_factory=dict)
 
 
 class PydanticBaseModel(PydanticTemplateModel):
@@ -141,7 +142,7 @@ class PydanticBaseModel(PydanticTemplateModel):
     """
     Sets the ``extra`` model for pydantic models
     """
-    fields: Optional[List[str]] = None
+    fields: Optional[list[str]] = None
     """
     Extra fields that are typically injected into the base model via
     :attr:`~linkml.generators.pydanticgen.PydanticGenerator.injected_fields`
@@ -166,7 +167,7 @@ class PydanticAttribute(PydanticTemplateModel):
     """
 
     template: ClassVar[str] = "attribute.py.jinja"
-    meta_exclude: ClassVar[List[str]] = ["from_schema", "owner", "range", "inlined", "inlined_as_list"]
+    meta_exclude: ClassVar[list[str]] = ["from_schema", "owner", "range", "inlined", "inlined_as_list"]
 
     name: str
     required: bool = False
@@ -186,7 +187,7 @@ class PydanticAttribute(PydanticTemplateModel):
     maximum_cardinality: Optional[int] = None
     multivalued: Optional[bool] = None
     pattern: Optional[str] = None
-    meta: Optional[Dict[str, Any]] = None
+    meta: Optional[dict[str, Any]] = None
     """
     Metadata for the slot to be included in a Field annotation
     """
@@ -222,29 +223,29 @@ class PydanticClass(PydanticTemplateModel):
     """
 
     template: ClassVar[str] = "class.py.jinja"
-    meta_exclude: ClassVar[List[str]] = ["slots", "is_a"]
+    meta_exclude: ClassVar[list[str]] = ["slots", "is_a"]
 
     name: str
-    bases: Union[List[str], str] = PydanticBaseModel.default_name
+    bases: Union[list[str], str] = PydanticBaseModel.default_name
     description: Optional[str] = None
-    attributes: Optional[Dict[str, PydanticAttribute]] = None
-    meta: Optional[Dict[str, Any]] = None
+    attributes: Optional[dict[str, PydanticAttribute]] = None
+    meta: Optional[dict[str, Any]] = None
     """
     Metadata for the class to be included in a linkml_meta class attribute
     """
 
-    def _validators(self) -> Optional[Dict[str, PydanticValidator]]:
+    def _validators(self) -> Optional[dict[str, PydanticValidator]]:
         if self.attributes is None:
             return None
 
         return {k: PydanticValidator(**v.model_dump()) for k, v in self.attributes.items() if v.pattern is not None}
 
     @computed_field
-    def validators(self) -> Optional[Dict[str, PydanticValidator]]:
+    def validators(self) -> Optional[dict[str, PydanticValidator]]:
         return self._validators()
 
     @computed_field
-    def slots(self) -> Optional[Dict[str, PydanticAttribute]]:
+    def slots(self) -> Optional[dict[str, PydanticAttribute]]:
         """alias of attributes"""
         return self.attributes
 
@@ -293,7 +294,7 @@ class Import(PydanticTemplateModel):
     template: ClassVar[str] = "imports.py.jinja"
     module: str
     alias: Optional[str] = None
-    objects: Optional[List[ObjectImport]] = None
+    objects: Optional[list[ObjectImport]] = None
     is_schema: bool = False
     """
     Whether or not this ``Import`` is importing another schema imported by the main schema --
@@ -323,7 +324,7 @@ class Import(PydanticTemplateModel):
         else:
             return "thirdparty"
 
-    def merge(self, other: "Import") -> List["Import"]:
+    def merge(self, other: "Import") -> list["Import"]:
         """
         Merge one import with another, see :meth:`.Imports` for an example.
 
@@ -440,7 +441,7 @@ class ConditionalImport(Import):
         """
         :meth:`.Import.sort` called for self and :attr:`.alternative`
         """
-        super(ConditionalImport, self).sort()
+        super().sort()
         self.alternative.sort()
 
 
@@ -478,16 +479,16 @@ class Imports(PydanticTemplateModel):
 
     template: ClassVar[str] = "imports.py.jinja"
 
-    imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
-    group_order: Tuple[str, ...] = get_args(IMPORT_GROUPS)
+    imports: list[Union[Import, ConditionalImport]] = Field(default_factory=list)
+    group_order: tuple[str, ...] = get_args(IMPORT_GROUPS)
     """Order in which to sort imports by their :attr:`.Import.group`"""
     render_sorted: bool = True
     """When rendering, render in sorted groups"""
 
     @classmethod
     def _merge(
-        cls, imports: List[Union[Import, ConditionalImport]], other: Union[Import, "Imports", List[Import]]
-    ) -> List[Union[Import, ConditionalImport]]:
+        cls, imports: list[Union[Import, ConditionalImport]], other: Union[Import, "Imports", list[Import]]
+    ) -> list[Union[Import, ConditionalImport]]:
         """
         Add a new import to an existing imports list, handling deduplication and flattening.
 
@@ -545,7 +546,7 @@ class Imports(PydanticTemplateModel):
         imports = sorted(imports, key=lambda i: i.module == "__future__", reverse=True)
         return imports
 
-    def __add__(self, other: Union[Import, "Imports", List[Import]]) -> "Imports":
+    def __add__(self, other: Union[Import, "Imports", list[Import]]) -> "Imports":
         imports = self.imports.copy()
         imports = self._merge(imports, other)
         return Imports.model_construct(
@@ -556,8 +557,7 @@ class Imports(PydanticTemplateModel):
         return len(self.imports)
 
     def __iter__(self) -> Generator[Import, None, None]:
-        for i in self.imports:
-            yield i
+        yield from self.imports
 
     def __getitem__(self, item: Union[int, str]) -> Import:
         if isinstance(item, int):
@@ -571,7 +571,7 @@ class Imports(PydanticTemplateModel):
         else:
             raise TypeError(f"Can only index with an int or a string as the name of the module,\nGot: {type(item)}")
 
-    def __contains__(self, item: Union[Import, "Imports", List[Import]]) -> bool:
+    def __contains__(self, item: Union[Import, "Imports", list[Import]]) -> bool:
         """
         Check if all the objects are imported from the given module(s)
 
@@ -601,8 +601,8 @@ class Imports(PydanticTemplateModel):
     @field_validator("imports", mode="after")
     @classmethod
     def imports_are_merged(
-        cls, imports: List[Union[Import, ConditionalImport]]
-    ) -> List[Union[Import, ConditionalImport]]:
+        cls, imports: list[Union[Import, ConditionalImport]]
+    ) -> list[Union[Import, ConditionalImport]]:
         """
         When creating from a list of imports, construct model as if we have done so by iteratively
         constructing with __add__ calls
@@ -613,7 +613,7 @@ class Imports(PydanticTemplateModel):
         return merged_imports
 
     @computed_field
-    def import_groups(self) -> List[IMPORT_GROUPS]:
+    def import_groups(self) -> list[IMPORT_GROUPS]:
         """
         List of what group each import belongs to
         """
@@ -629,7 +629,7 @@ class Imports(PydanticTemplateModel):
         * Then alphabetically by module name
         """
 
-        def _sort_key(i: Import) -> Tuple[int, int, str]:
+        def _sort_key(i: Import) -> tuple[int, int, str]:
             return (self.group_order.index(i.group), int(i.objects is not None), i.module)
 
         imports = sorted(self.imports, key=_sort_key)
@@ -640,7 +640,7 @@ class Imports(PydanticTemplateModel):
     def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
         if self.render_sorted:
             self.sort()
-        return super(Imports, self).render(environment=environment, black=black)
+        return super().render(environment=environment, black=black)
 
 
 class PydanticModule(PydanticTemplateModel):
@@ -654,24 +654,24 @@ class PydanticModule(PydanticTemplateModel):
     metamodel_version: Optional[str] = None
     version: Optional[str] = None
     base_model: PydanticBaseModel = PydanticBaseModel()
-    injected_classes: Optional[List[str]] = None
-    python_imports: Union[Imports, List[Union[Import, ConditionalImport]]] = Imports()
-    enums: Dict[str, PydanticEnum] = Field(default_factory=dict)
-    classes: Dict[str, PydanticClass] = Field(default_factory=dict)
-    meta: Optional[Dict[str, Any]] = None
+    injected_classes: Optional[list[str]] = None
+    python_imports: Union[Imports, list[Union[Import, ConditionalImport]]] = Imports()
+    enums: dict[str, PydanticEnum] = Field(default_factory=dict)
+    classes: dict[str, PydanticClass] = Field(default_factory=dict)
+    meta: Optional[dict[str, Any]] = None
     """
     Metadata for the schema to be included in a linkml_meta module-level instance of LinkMLMeta
     """
 
     @field_validator("python_imports", mode="after")
     @classmethod
-    def cast_imports(cls, imports: Union[Imports, List[Union[Import, ConditionalImport]]]) -> Imports:
+    def cast_imports(cls, imports: Union[Imports, list[Union[Import, ConditionalImport]]]) -> Imports:
         if isinstance(imports, list):
             imports = Imports(imports=imports)
         return imports
 
     @computed_field
-    def class_names(self) -> List[str]:
+    def class_names(self) -> list[str]:
         return [c.name for c in self.classes.values()]
 
 

linkml/generators/pythongen.py

@@ -2,11 +2,12 @@ import keyword
 import logging
 import os
 import re
+from collections.abc import Iterator
 from copy import copy
 from dataclasses import dataclass
 from pathlib import Path
 from types import ModuleType
-from typing import Callable, Dict, Iterator, List, Optional, Set, Tuple, Union
+from typing import Callable, Optional, Union
 
 import click
 from linkml_runtime import SchemaView
@@ -204,12 +205,6 @@ class PythonGenerator(Generator):
                     ObjectImport(name="extended_int"),
                 ],
             )
-            + Import(
-                module="linkml_runtime.utils.dataclass_extensions_376",
-                objects=[
-                    ObjectImport(name="dataclasses_init_fn_with_kwargs"),
-                ],
-            )
             + Import(
                 module="linkml_runtime.utils.formatutils",
                 objects=[
@@ -265,9 +260,6 @@ class PythonGenerator(Generator):
 metamodel_version = "{self.schema.metamodel_version}"
 version = {'"' + self.schema.version + '"' if self.schema.version else None}
 
-# Overwrite dataclasses _init_fn to add **kwargs in __init__
-dataclasses._init_fn = dataclasses_init_fn_with_kwargs
-
 # Namespaces
 {self.gen_namespaces()}
 
@@ -292,7 +284,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         list_ents = [f"from {k} import {', '.join(v)}" for k, v in self.gen_import_list().items()]
         return "\n".join(list_ents)
 
-    def gen_import_list(self) -> Dict[str, List[str]]:
+    def gen_import_list(self) -> dict[str, list[str]]:
         """
         Generate a list of types to import
 
@@ -302,7 +294,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         class ImportList:
             def __init__(self, schema_location: str):
                 self.schema_location = schema_location
-                self.v: Dict[str, Set[str]] = {}
+                self.v: dict[str, set[str]] = {}
 
             def add_element(self, e: Element) -> None:
                 if e.imported_from:
@@ -324,7 +316,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
                 else:
                     innerself.v.setdefault(". " + path, set()).add(name)
 
-            def values(self) -> Dict[str, List[str]]:
+            def values(self) -> dict[str, list[str]]:
                 return {k: sorted(self.v[k]) for k in sorted(self.v.keys())}
 
         def add_type_ref(typ: TypeDefinition) -> None:
@@ -515,7 +507,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             if slot.inherited:
                 inherited_slots.append(slot.alias if slot.alias else slotname)
         inherited_slots_str = ", ".join([f'"{underscore(s)}"' for s in inherited_slots])
-        return f"\n\t_inherited_slots: ClassVar[List[str]] = [{inherited_slots_str}]\n"
+        return f"\n\t_inherited_slots: ClassVar[list[str]] = [{inherited_slots_str}]\n"
 
     def gen_class_meta(self, cls: ClassDefinition) -> str:
         if not self.gen_classvars:
@@ -638,7 +630,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         slot: SlotDefinition,
         cls: Optional[ClassDefinition],
         positional_allowed: bool,
-    ) -> Tuple[str, Optional[str]]:
+    ) -> tuple[str, Optional[str]]:
         """
         Return the range type including initializers, etc.
         Generate a class variable declaration for the supplied slot.  Note: the positional_allowed attribute works,
@@ -663,33 +655,33 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             if num_elements == 1:
                 if slot.required:
                     return (
-                        f"Union[List[{base_key}], Dict[{base_key}, {range_type}]]",
+                        f"Union[list[{base_key}], dict[{base_key}, {range_type}]]",
                         dflt,
                     )
                 else:
                     return (
-                        f"Optional[Union[List[{base_key}], Dict[{base_key}, {range_type}]]]",
+                        f"Optional[Union[list[{base_key}], dict[{base_key}, {range_type}]]]",
                         dflt,
                     )
             else:
                 if slot.required:
                     return (
-                        f"Union[Dict[{base_key}, {range_type}], List[{range_type}]]",
+                        f"Union[dict[{base_key}, {range_type}], list[{range_type}]]",
                         dflt,
                     )
                 else:
                     return (
-                        f"Optional[Union[Dict[{base_key}, {range_type}], List[{range_type}]]]",
+                        f"Optional[Union[dict[{base_key}, {range_type}], list[{range_type}]]]",
                         dflt,
                     )
 
         # All other cases
         if slot.multivalued:
             if slot.required:
-                return f"Union[{range_type}, List[{range_type}]]", (None if positional_allowed else "None")
+                return f"Union[{range_type}, list[{range_type}]]", (None if positional_allowed else "None")
             else:
                 return (
-                    f"Optional[Union[{range_type}, List[{range_type}]]]",
+                    f"Optional[Union[{range_type}, list[{range_type}]]]",
                     "empty_list()",
                 )
         elif slot.required:
@@ -697,7 +689,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         else:
             return f"Optional[{range_type}]", "None"
 
-    def class_reference_type(self, slot: SlotDefinition, cls: Optional[ClassDefinition]) -> Tuple[str, str, str]:
+    def class_reference_type(self, slot: SlotDefinition, cls: Optional[ClassDefinition]) -> tuple[str, str, str]:
         """
         Return the type of slot referencing a class
 
@@ -719,7 +711,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         return str(self.gen_class_reference(rangelist)), prox_type, prox_type_name
 
     @staticmethod
-    def gen_class_reference(rangelist: List[str]) -> str:
+    def gen_class_reference(rangelist: list[str]) -> str:
         """
         Return a basic or a union type depending on the number of elements in range list
 
@@ -766,7 +758,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         return (
             (
                 f"""
-    def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]):
+    def __post_init__(self, *_: str, **kwargs: Any):
         {post_inits_line}
         super().__post_init__(**kwargs)
         {post_inits_post_super_line}"""
@@ -777,7 +769,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     # sort classes such that if C is a child of P then C appears after P in the list
     @staticmethod
-    def _sort_classes(clist: List[ClassDefinition]) -> List[ClassDefinition]:
+    def _sort_classes(clist: list[ClassDefinition]) -> list[ClassDefinition]:
         clist = list(clist)
         slist = []  # sorted
         while len(clist) > 0:
@@ -825,7 +817,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         :param cls: class to generate constructor for
         :return: python constructor
         """
-        rlines: List[str] = []
+        rlines: list[str] = []
         designators = [x for x in self.domain_slots(cls) if x.designates_type]
         if len(designators) > 0:
             descendants = self.schemaview.class_descendants(cls.name)
@@ -880,7 +872,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def gen_postinit(self, cls: ClassDefinition, slot: SlotDefinition) -> Optional[str]:
         """Generate python post init rules for slot in class"""
-        rlines: List[str] = []
+        rlines: list[str] = []
 
         if slot.range in self.schema.classes:
             if self.is_class_unconstrained(self.schema.classes[slot.range]):
@@ -1018,7 +1010,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
                 if first_hit_only:
                     break
 
-    def primary_keys_for(self, cls: ClassDefinition) -> List[SlotDefinitionName]:
+    def primary_keys_for(self, cls: ClassDefinition) -> list[SlotDefinitionName]:
         """Return the primary key for cls.
 
         Note: At the moment we return at most one entry.  At some point, keys will be expanded to support
@@ -1068,7 +1060,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
                 return False  # Occurs before
         return True
 
-    def python_uri_for(self, uriorcurie: Union[str, URIRef]) -> Tuple[str, Optional[str]]:
+    def python_uri_for(self, uriorcurie: Union[str, URIRef]) -> tuple[str, Optional[str]]:
         """Return the python form of uriorcurie
         :param uriorcurie:
         :return: URI and CURIE form

linkml/generators/rdfgen.py

@@ -9,7 +9,7 @@ import os
 import urllib.parse as urlparse
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 import click
 from linkml_runtime.linkml_model import SchemaDefinition
@@ -36,7 +36,7 @@ class RDFGenerator(Generator):
 
     # ObjectVars
     emit_metadata: bool = False
-    context: List[str] = None
+    context: list[str] = None
     original_schema: SchemaDefinition = None
     """See https://github.com/linkml/linkml/issues/871"""