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

linkml/generators/oocodegen.py

@@ -2,7 +2,7 @@ import abc
 import re
 import unicodedata
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional
+from typing import Optional
 
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
@@ -32,8 +32,8 @@ class OODocument:
     name: SAFE_NAME
     package: PACKAGE = None
     source_schema: SchemaDefinition = None
-    classes: List["OOClass"] = field(default_factory=lambda: [])
-    imports: List[str] = field(default_factory=lambda: [])
+    classes: list["OOClass"] = field(default_factory=lambda: [])
+    imports: list[str] = field(default_factory=lambda: [])
 
 
 @dataclass
@@ -45,7 +45,7 @@ class OOField:
     name: SAFE_NAME
     range: TYPE_EXPRESSION = None
     default_value: str = None
-    annotations: List[ANNOTATION] = field(default_factory=lambda: [])
+    annotations: list[ANNOTATION] = field(default_factory=lambda: [])
     source_slot: SlotDefinition = field(default_factory=lambda: [])
 
 
@@ -61,10 +61,10 @@ class OOClass:
     is_a: Optional[SAFE_NAME] = None
     mixin: Optional[bool] = None
     abstract: Optional[bool] = None
-    mixins: List[SAFE_NAME] = field(default_factory=lambda: [])
-    fields: List[OOField] = field(default_factory=lambda: [])
-    all_fields: List[OOField] = field(default_factory=lambda: [])
-    annotations: List[ANNOTATION] = field(default_factory=lambda: [])
+    mixins: list[SAFE_NAME] = field(default_factory=lambda: [])
+    fields: list[OOField] = field(default_factory=lambda: [])
+    all_fields: list[OOField] = field(default_factory=lambda: [])
+    annotations: list[ANNOTATION] = field(default_factory=lambda: [])
     package: PACKAGE = None
     source_class: ClassDefinition = None
 
@@ -135,7 +135,7 @@ class OOCodeGenerator(Generator):
 
             return safe_label
 
-    def generate_enums(self, all_enums: Dict[EnumDefinitionName, EnumDefinition]) -> Dict:
+    def generate_enums(self, all_enums: dict[EnumDefinitionName, EnumDefinition]) -> dict:
         # TODO: make an explicit class to represent how an enum is passed to the template
         enums = {}
         for enum_name, enum_original in all_enums.items():
@@ -161,7 +161,7 @@ class OOCodeGenerator(Generator):
 
         return enums
 
-    def create_documents(self) -> List[OODocument]:
+    def create_documents(self) -> list[OODocument]:
         """
         Currently hardcoded for java-style
         :return:

linkml/generators/owlgen.py

@@ -3,10 +3,11 @@
 import logging
 import os
 from collections import defaultdict
+from collections.abc import Mapping
 from copy import copy
 from dataclasses import dataclass, field
 from enum import Enum, unique
-from typing import Any, List, Mapping, Optional, Set, Tuple, Union
+from typing import Any, Optional, Union
 
 import click
 import rdflib
@@ -117,7 +118,7 @@ class OwlSchemaGenerator(Generator):
     metadata_profile: MetadataProfile = None
     """Deprecated - use metadata_profiles."""
 
-    metadata_profiles: List[MetadataProfile] = field(default_factory=lambda: [])
+    metadata_profiles: list[MetadataProfile] = field(default_factory=lambda: [])
     """By default, use the linkml metadata profile,
     this allows for overrides."""
 
@@ -151,10 +152,10 @@ class OwlSchemaGenerator(Generator):
 
     default_permissible_value_type: Union[str, URIRef] = field(default_factory=lambda: OWL.Class)
 
-    slot_is_literal_map: Mapping[str, Set[bool]] = field(default_factory=lambda: defaultdict(set))
+    slot_is_literal_map: Mapping[str, set[bool]] = field(default_factory=lambda: defaultdict(set))
     """DEPRECATED: use node_owltypes"""
 
-    node_owltypes: Mapping[Union[BNode, URIRef], Set[OWL_TYPE]] = field(default_factory=lambda: defaultdict(set))
+    node_owltypes: Mapping[Union[BNode, URIRef], set[OWL_TYPE]] = field(default_factory=lambda: defaultdict(set))
     """rdfs:Datatype, owl:Thing"""
 
     simplify: bool = True
@@ -425,7 +426,7 @@ class OwlSchemaGenerator(Generator):
             else:
                 self.graph.add((subject_expr, RDFS.subClassOf, superclass_expr))
 
-    def get_own_slots(self, cls: Union[ClassDefinition, AnonymousClassExpression]) -> List[SlotDefinition]:
+    def get_own_slots(self, cls: Union[ClassDefinition, AnonymousClassExpression]) -> list[SlotDefinition]:
         """
         Get the slots that are defined on a class, excluding those that are inherited.
 
@@ -561,7 +562,7 @@ class OwlSchemaGenerator(Generator):
         self,
         slot: Union[SlotDefinition, AnonymousSlotExpression],
         owning_class: Optional[Union[ClassDefinition, AnonymousClassExpression]] = None,
-    ) -> Set[URIRef]:
+    ) -> set[URIRef]:
         """
         Determine the OWL types of a named slot or slot expression
 
@@ -594,7 +595,7 @@ class OwlSchemaGenerator(Generator):
         cls: Optional[Union[ClassDefinition, AnonymousClassExpression]],
         slot: Union[SlotDefinition, AnonymousSlotExpression],
         main_slot: SlotDefinition = None,
-        owl_types: Set[OWL_TYPE] = None,
+        owl_types: set[OWL_TYPE] = None,
     ) -> Optional[Union[BNode, URIRef]]:
         """
         Take a ClassExpression and SlotExpression combination and transform to a node.
@@ -685,7 +686,7 @@ class OwlSchemaGenerator(Generator):
         self,
         element: Union[SlotDefinition, AnonymousSlotExpression, TypeDefinition, AnonymousTypeExpression],
         is_literal: Optional[bool] = None,
-    ) -> Tuple[List[BNode], Set[OWL_TYPE]]:
+    ) -> tuple[list[BNode], set[OWL_TYPE]]:
         owl_types = set()
         owl_exprs = []
         graph = self.graph
@@ -978,7 +979,7 @@ class OwlSchemaGenerator(Generator):
         subject: Union[URIRef, BNode],
         condition: AnonymousClassExpression,
         cls: ClassDefinition,
-    ) -> List[BNode]:
+    ) -> list[BNode]:
         for slot_name, expr in condition.slot_conditions.items():
             var = self._swrl_var(slot_name)
             if expr.maximum_value is not None:
@@ -996,7 +997,7 @@ class OwlSchemaGenerator(Generator):
             return True
         return profile in self.metadata_profiles or profile == self.metadata_profile
 
-    def _get_owltypes(self, current: Set[OWL_TYPE], exprs: List[Union[BNode, URIRef]]) -> Set[OWL_TYPE]:
+    def _get_owltypes(self, current: set[OWL_TYPE], exprs: list[Union[BNode, URIRef]]) -> set[OWL_TYPE]:
         """
         Gets the OWL types of specified expressions plus current owl types.
 
@@ -1076,7 +1077,7 @@ class OwlSchemaGenerator(Generator):
         return URIRef("https://w3id.org/linkml/" + name)
 
     def _complement_of_union_of(
-        self, exprs: List[Union[BNode, URIRef]], owl_types: Set[OWL_TYPE] = None, **kwargs
+        self, exprs: list[Union[BNode, URIRef]], owl_types: set[OWL_TYPE] = None, **kwargs
     ) -> Optional[Union[BNode, URIRef]]:
         if not exprs:
             raise ValueError("Must pass at least one")
@@ -1092,16 +1093,16 @@ class OwlSchemaGenerator(Generator):
 
         return neg_expr
 
-    def _intersection_of(self, exprs: List[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
+    def _intersection_of(self, exprs: list[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
         return self._boolean_expression(exprs, OWL.intersectionOf, **kwargs)
 
-    def _union_of(self, exprs: List[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
+    def _union_of(self, exprs: list[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
         return self._boolean_expression(exprs, OWL.unionOf, **kwargs)
 
-    def _object_one_of(self, exprs: List[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
+    def _object_one_of(self, exprs: list[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
         return self._boolean_expression(exprs, OWL.oneOf, **kwargs)
 
-    def _exactly_one_of(self, exprs: List[Union[BNode, URIRef]]) -> Optional[Union[BNode, URIRef]]:
+    def _exactly_one_of(self, exprs: list[Union[BNode, URIRef]]) -> Optional[Union[BNode, URIRef]]:
         if not exprs:
             raise ValueError("Must pass at least one")
         if len(exprs) == 1:
@@ -1113,7 +1114,7 @@ class OwlSchemaGenerator(Generator):
             sub_exprs.append(self._intersection_of([x, neg_expr]))
         return self._union_of(sub_exprs)
 
-    def _datatype_restriction(self, datatype: URIRef, facets: List[Union[BNode, URIRef]]) -> BNode:
+    def _datatype_restriction(self, datatype: URIRef, facets: list[Union[BNode, URIRef]]) -> BNode:
         node = BNode()
         graph = self.graph
         graph.add((node, RDF.type, RDFS.Datatype))
@@ -1132,10 +1133,10 @@ class OwlSchemaGenerator(Generator):
 
     def _boolean_expression(
         self,
-        exprs: List[Union[BNode, URIRef, Literal]],
+        exprs: list[Union[BNode, URIRef, Literal]],
         predicate: URIRef,
         node: Optional[URIRef] = None,
-        owl_types: Set[OWL_TYPE] = None,
+        owl_types: set[OWL_TYPE] = None,
     ) -> Optional[Union[BNode, URIRef]]:
         graph = self.graph
         if [x for x in exprs if x is None]:

linkml/generators/plantumlgen.py

@@ -8,7 +8,7 @@ import base64
 import os
 import zlib
 from dataclasses import dataclass
-from typing import Callable, List, Optional, Set, cast
+from typing import Callable, Optional, cast
 
 import click
 import requests
@@ -38,15 +38,15 @@ class PlantumlGenerator(Generator):
     valid_formats = ["puml", "plantuml", "png", "pdf", "jpg", "json", "svg"]
     visit_all_class_slots = False
 
-    referenced: Optional[Set[ClassDefinitionName]] = None  # List of classes that have to be emitted
-    generated: Optional[Set[ClassDefinitionName]] = None  # List of classes that have been emitted
-    class_generated: Optional[Set[ClassDefinitionName]] = None  # Class definitions that have been emitted
-    associations_generated: Optional[Set[ClassDefinitionName]] = None  # Classes with associations generated
-    focus_classes: Optional[Set[ClassDefinitionName]] = None  # Classes to be completely filled
-    gen_classes: Optional[Set[ClassDefinitionName]] = None  # Classes to be generated
+    referenced: Optional[set[ClassDefinitionName]] = None  # List of classes that have to be emitted
+    generated: Optional[set[ClassDefinitionName]] = None  # List of classes that have been emitted
+    class_generated: Optional[set[ClassDefinitionName]] = None  # Class definitions that have been emitted
+    associations_generated: Optional[set[ClassDefinitionName]] = None  # Classes with associations generated
+    focus_classes: Optional[set[ClassDefinitionName]] = None  # Classes to be completely filled
+    gen_classes: Optional[set[ClassDefinitionName]] = None  # Classes to be generated
     output_file_name: Optional[str] = None  # Location of output file if directory used
 
-    classes: Set[ClassDefinitionName] = None
+    classes: set[ClassDefinitionName] = None
     directory: Optional[str] = None
     kroki_server: Optional[str] = "https://kroki.io"
     tooltips_flag: bool = False
@@ -54,7 +54,7 @@ class PlantumlGenerator(Generator):
 
     def visit_schema(
         self,
-        classes: Set[ClassDefinitionName] = None,
+        classes: set[ClassDefinitionName] = None,
         directory: Optional[str] = None,
         **_,
     ) -> Optional[str]:
@@ -76,7 +76,7 @@ class PlantumlGenerator(Generator):
             self.gen_classes = self.synopsis.roots.classrefs
         self.referenced = self.gen_classes
         self.generated = set()
-        plantumlclassdef: List[str] = []
+        plantumlclassdef: list[str] = []
         while self.referenced.difference(self.generated):
             cn = sorted(list(self.referenced.difference(self.generated)), reverse=True)[0]
             self.generated.add(cn)
@@ -127,7 +127,7 @@ class PlantumlGenerator(Generator):
         @param cn:
         @return:
         """
-        slot_defs: List[str] = []
+        slot_defs: list[str] = []
         if cn not in self.class_generated and (not self.focus_classes or cn in self.focus_classes):
             cls = self.schema.classes[cn]
             for slot in self.filtered_cls_slots(cn, all_slots=True, filtr=lambda s: s.range not in self.schema.classes):
@@ -168,8 +168,8 @@ class PlantumlGenerator(Generator):
         @return: PLANTUML representation of the association
         """
 
-        classes: List[str] = []
-        assocs: List[str] = []
+        classes: list[str] = []
+        assocs: list[str] = []
         if cn not in self.associations_generated and (not self.focus_classes or cn in self.focus_classes):
             cls = self.schema.classes[cn]
 
@@ -271,7 +271,7 @@ class PlantumlGenerator(Generator):
                 if cn not in self.class_generated:
                     classes.append(self.add_class(cn))
                 assocs.append('"' + cls.is_a + '" ' + plantuml_is_a + ' "' + cn + '"')
-        entries: List[str] = []
+        entries: list[str] = []
         entries.extend(classes)
         entries.extend(assocs)
         return entries
@@ -294,7 +294,7 @@ class PlantumlGenerator(Generator):
         cn: ClassDefinitionName,
         all_slots: bool = True,
         filtr: Callable[[SlotDefinition], bool] = None,
-    ) -> List[SlotDefinition]:
+    ) -> list[SlotDefinition]:
         """Return the set of slots associated with the class that meet the filter criteria.  Slots will be returned
         in defining order, with class slots returned last
 

linkml/generators/prefixmapgen.py

@@ -5,7 +5,7 @@ Generate JSON-LD contexts
 
 import os
 from dataclasses import dataclass, field
-from typing import Dict, Optional, Set, Union
+from typing import Optional, Union
 
 import click
 from jsonasobj2 import JsonObj, as_json
@@ -30,10 +30,10 @@ class PrefixGenerator(Generator):
     uses_schemaloader = True
 
     # ObjectVars
-    emit_prefixes: Set[str] = field(default_factory=lambda: set())
+    emit_prefixes: set[str] = field(default_factory=lambda: set())
     default_ns: str = None
-    context_body: Dict = field(default_factory=lambda: dict())
-    slot_class_maps: Dict = field(default_factory=lambda: dict())
+    context_body: dict = field(default_factory=lambda: dict())
+    slot_class_maps: dict = field(default_factory=lambda: dict())
     base: Optional[Union[str, Namespace]] = None
 
     def __post_init__(self):
@@ -74,7 +74,7 @@ class PrefixGenerator(Generator):
             context[k] = v
 
         if self.format == "tsv":
-            mapping: Dict = {}  # prefix to IRI mapping
+            mapping: dict = {}  # prefix to IRI mapping
             for prefix in sorted(self.emit_prefixes):
                 mapping[prefix] = self.namespaces[prefix]
 

linkml/generators/projectgen.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Dict, List, Tuple, Type
+from typing import Any
 
 import click
 import yaml
@@ -30,9 +30,9 @@ logger = logging.getLogger(__name__)
 
 PATH_FSTRING = str
 GENERATOR_NAME = str
-ARG_DICT = Dict[str, Any]
-CONFIG_TUPLE = Tuple[Type[Generator], PATH_FSTRING, ARG_DICT]
-GEN_MAP: Dict[GENERATOR_NAME, CONFIG_TUPLE]
+ARG_DICT = dict[str, Any]
+CONFIG_TUPLE = tuple[type[Generator], PATH_FSTRING, ARG_DICT]
+GEN_MAP: dict[GENERATOR_NAME, CONFIG_TUPLE]
 GEN_MAP = {
     "graphql": (GraphqlGenerator, "graphql/{name}.graphql", {}),
     "jsonldcontext": (ContextGenerator, "jsonld/{name}.context.jsonld", {}),
@@ -63,7 +63,7 @@ GEN_MAP = {
 }
 
 
-@lru_cache()
+@lru_cache
 def get_local_imports(schema_path: str, dir: str):
     logger.info(f"GETTING IMPORTS = {schema_path}")
     all_imports = [schema_path]
@@ -85,9 +85,9 @@ class ProjectConfiguration:
     """
 
     directory: str = "tmp"
-    generator_args: Dict[GENERATOR_NAME, ARG_DICT] = field(default_factory=lambda: defaultdict(dict))
-    includes: List[str] = None
-    excludes: List[str] = None
+    generator_args: dict[GENERATOR_NAME, ARG_DICT] = field(default_factory=lambda: defaultdict(dict))
+    includes: list[str] = None
+    excludes: list[str] = None
     mergeimports: bool = None
 
 
@@ -188,8 +188,8 @@ class ProjectGenerator:
 def cli(
     yamlfile,
     dir,
-    exclude: List[str],
-    include: List[str],
+    exclude: list[str],
+    include: list[str],
     config_file,
     mergeimports,
     generator_arguments: str,

linkml/generators/pydanticgen/array.py

@@ -3,10 +3,7 @@ from abc import ABC, abstractmethod
 from enum import Enum
 from typing import (
     ClassVar,
-    Iterable,
-    List,
     Optional,
-    Type,
     TypeVar,
     Union,
 )
@@ -40,14 +37,13 @@ class ArrayRepresentation(Enum):
 _BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions", "maximum_number_dimensions")
 
 _T = TypeVar("_T")
-AnyShapeArray = TypeAliasType("AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,))
+AnyShapeArray = TypeAliasType("AnyShapeArray", list[Union[_T, "AnyShapeArray[_T]"]], type_params=(_T,))
 
 _AnyShapeArrayImports = (
     Imports()
     + Import(
         module="typing",
         objects=[
-            ObjectImport(name="Iterable"),
             ObjectImport(name="TypeVar"),
             ObjectImport(name="Union"),
         ],
@@ -64,7 +60,7 @@ _AnyShapeArrayImports = (
 _AnyShapeArrayInjects = [
     '_T = TypeVar("_T")',
     """AnyShapeArray = TypeAliasType(
-    "AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,)
+    "AnyShapeArray", list[Union[_T, "AnyShapeArray[_T]"]], type_params=(_T,)
 )""",
 ]
 
@@ -161,11 +157,9 @@ class ArrayValidator:
         """
         if array.minimum_number_dimensions is not None and array.maximum_number_dimensions is None and array.dimensions:
             raise ValidationError(
-                (
-                    "Cannot specify a minimum_number_dimensions while maximum is None while using labeled dimensions - "
-                    "either use exact_number_dimensions > len(dimensions) for extra parameterized dimensions or set "
-                    "maximum_number_dimensions explicitly to False for unbounded dimensions"
-                )
+                "Cannot specify a minimum_number_dimensions while maximum is None while using labeled dimensions - "
+                "either use exact_number_dimensions > len(dimensions) for extra parameterized dimensions or set "
+                "maximum_number_dimensions explicitly to False for unbounded dimensions"
             )
 
     @staticmethod
@@ -256,7 +250,7 @@ class ArrayRangeGenerator(ABC):
         return any([getattr(self.array, arr_field, None) is not None for arr_field in _BOUNDED_ARRAY_FIELDS])
 
     @classmethod
-    def get_generator(cls, repr: ArrayRepresentation) -> Type["ArrayRangeGenerator"]:
+    def get_generator(cls, repr: ArrayRepresentation) -> type["ArrayRangeGenerator"]:
         """Get the generator class for a given array representation"""
         for subclass in cls.__subclasses__():
             if repr in (subclass.REPR, subclass.REPR.value):
@@ -293,7 +287,7 @@ class ListOfListsArray(ArrayRangeGenerator):
 
     @staticmethod
     def _list_of_lists(dimensions: int, dtype: str) -> str:
-        return ("List[" * dimensions) + dtype + ("]" * dimensions)
+        return ("list[" * dimensions) + dtype + ("]" * dimensions)
 
     @staticmethod
     def _parameterized_dimension(dimension: DimensionExpression, dtype: str) -> RangeResult:
@@ -306,7 +300,7 @@ class ListOfListsArray(ArrayRangeGenerator):
             dmax = dimension.maximum_cardinality
         else:
             # TODO: handle labels for labeled but unshaped arrays
-            return RangeResult(range="List[" + dtype + "]")
+            return RangeResult(range="list[" + dtype + "]")
 
         items = []
         if dmin is not None:
@@ -341,7 +335,7 @@ class ListOfListsArray(ArrayRangeGenerator):
 
     def _bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
-        A nested series of ``List[]`` ranges with :attr:`.dtype` at the center.
+        A nested series of ``list[]`` ranges with :attr:`.dtype` at the center.
 
         When an array expression allows for a range of dimensions, each set of ``List`` s is joined by a ``Union`` .
         """
@@ -357,13 +351,13 @@ class ListOfListsArray(ArrayRangeGenerator):
         ):
             return self._any_shape()
         elif array.maximum_number_dimensions:
-            # e.g., if min = 2, max = 3, range = Union[List[List[dtype]], List[List[List[dtype]]]]
+            # e.g., if min = 2, max = 3, range = Union[list[list[dtype]], list[list[list[dtype]]]]
             min_dims = array.minimum_number_dimensions if array.minimum_number_dimensions is not None else 1
             ranges = [self._list_of_lists(i, self.dtype) for i in range(min_dims, array.maximum_number_dimensions + 1)]
             return RangeResult(range="Union[" + ", ".join(ranges) + "]")
         else:
             # min specified with no max
-            # e.g., if min = 3, range = List[List[AnyShapeArray[dtype]]]
+            # e.g., if min = 3, range = list[list[AnyShapeArray[dtype]]]
             return RangeResult(
                 range=self._list_of_lists(array.minimum_number_dimensions - 1, self._any_shape().range),
                 injected_classes=_AnyShapeArrayInjects,
@@ -415,7 +409,7 @@ class ListOfListsArray(ArrayRangeGenerator):
 
             if array.minimum_number_dimensions:
                 # some minimum anonymous dimensions but unlimited max dimensions
-                # e.g., if min = 3, len(dim) = 2, then res.range = List[Union[AnyShapeArray[dtype], dtype]]
+                # e.g., if min = 3, len(dim) = 2, then res.range = list[Union[AnyShapeArray[dtype], dtype]]
                 # res.range will be wrapped with the 2 labeled dimensions later
                 res.range = self._list_of_lists(array.minimum_number_dimensions - len(array.dimensions), res.range)
 
@@ -433,13 +427,13 @@ class ListOfListsArray(ArrayRangeGenerator):
 
         # Wrap inner dimension with labeled dimension
         # e.g., if dimensions = [{min_card: 3}, {min_card: 2}]
-        # and res.range = List[Union[AnyShapeArray[dtype], dtype]]
+        # and res.range = list[Union[AnyShapeArray[dtype], dtype]]
         # (min 3 dims, no max dims)
         # then the final range = conlist(
         #     min_length=3,
         #     item_type=conlist(
         #         min_length=2,
-        #         item_type=List[Union[AnyShapeArray[dtype], dtype]]
+        #         item_type=list[Union[AnyShapeArray[dtype], dtype]]
         #     )
         # )
         for dim in reversed(array.dimensions):
@@ -473,7 +467,7 @@ class NumpydanticArray(ArrayRangeGenerator):
         return result
 
     @staticmethod
-    def ndarray_annotation(shape: Optional[List[Union[int, str]]] = None, dtype: Optional[str] = None) -> str:
+    def ndarray_annotation(shape: Optional[list[Union[int, str]]] = None, dtype: Optional[str] = None) -> str:
         """
         Make a stringified :class:`numpydantic.NDArray` annotation for a given shape
         and dtype.

linkml/generators/pydanticgen/build.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import List, Optional, Type, TypeVar, Union
+from typing import Optional, TypeVar, Union
 
 from linkml.generators.common.build import (
     BuildResult,
@@ -24,8 +24,8 @@ class PydanticBuildResult(BuildResult):
     BuildResult parent class for pydantic generator
     """
 
-    imports: Optional[Union[List[Import], Imports]] = None
-    injected_classes: Optional[List[Union[str, Type]]] = None
+    imports: Optional[Union[list[Import], Imports]] = None
+    injected_classes: Optional[list[Union[str, type]]] = None
 
     def merge(self, other: T) -> T:
         """
@@ -92,7 +92,7 @@ class RangeResult(PydanticBuildResult, RangeResult_):
         Returns:
             :class:`.SlotResult`
         """
-        res = super(RangeResult, self).merge(other)
+        res = super().merge(other)
         # Replace with other's annotation
         res.range = other.range
         if other.field_extras is not None:

linkml/generators/pydanticgen/includes.py

@@ -4,7 +4,7 @@ Classes to inject in generated pydantic models
 
 LinkMLMeta = """
 class LinkMLMeta(RootModel):
-    root: Dict[str, Any] = {}
+    root: dict[str, Any] = {}
     model_config = ConfigDict(frozen=True)
     
     def __getattr__(self, key:str):