linkml 1.8.0rc2__py3-none-any.whl → 1.8.2__py3-none-any.whl

linkml/generators/pydanticgen/array.py

@@ -1,24 +1,30 @@
 import sys
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, ClassVar, Generic, Iterable, List, Optional, Type, TypeVar, Union, get_args
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterable, Optional, Type, TypeVar, Union, get_args
 
 from linkml_runtime.linkml_model import Element
 from linkml_runtime.linkml_model.meta import ArrayExpression, DimensionExpression
 from pydantic import VERSION as PYDANTIC_VERSION
 
-if int(PYDANTIC_VERSION[0]) < 2:
-    pass
+from linkml.utils.deprecation import deprecation_warning
+
+if int(PYDANTIC_VERSION[0]) >= 2:
+    from pydantic_core import core_schema
 else:
+    # Support for having pydantic 1 installed in the same environment will be dropped in 1.9.0
+    deprecation_warning("pydantic-v1")
+
+if TYPE_CHECKING:
     from pydantic import GetCoreSchemaHandler
-    from pydantic_core import CoreSchema, core_schema
+    from pydantic_core import CoreSchema
 
 if sys.version_info.minor <= 8:
     from typing_extensions import Annotated
 else:
     from typing import Annotated
 
-from linkml.generators.pydanticgen.build import SlotResult
+from linkml.generators.pydanticgen.build import RangeResult
 from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
 
 
@@ -31,153 +37,81 @@ _BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions",
 
 _T = TypeVar("_T")
 _RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]
-if int(PYDANTIC_VERSION[0]) >= 2:
-
-    class AnyShapeArrayType(Generic[_T]):
-        @classmethod
-        def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:
-            # double-nested parameterized types here
-            # source_type: List[Union[T,List[...]]]
-            item_type = Any if get_args(get_args(source_type)[0])[0] is _T else get_args(get_args(source_type)[0])[0]
 
-            item_schema = handler.generate_schema(item_type)
-            if item_schema.get("type", "any") != "any":
-                item_schema["strict"] = True
 
-            if item_type is Any:
-                # Before python 3.11, `Any` type was a special object without a __name__
-                item_name = "Any"
-            else:
-                item_name = item_type.__name__
-
-            array_ref = f"any-shape-array-{item_name}"
-
-            schema = core_schema.definitions_schema(
-                core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
-                [
-                    core_schema.union_schema(
-                        [
-                            core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
-                            item_schema,
-                        ],
-                        ref=array_ref,
-                    )
-                ],
-            )
-
-            return schema
-
-    AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]
-
-    _AnyShapeArrayImports = (
-        Imports()
-        + Import(
-            module="typing",
-            objects=[
-                ObjectImport(name="Generic"),
-                ObjectImport(name="Iterable"),
-                ObjectImport(name="TypeVar"),
-                ObjectImport(name="Union"),
-                ObjectImport(name="get_args"),
+class AnyShapeArrayType(Generic[_T]):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: "GetCoreSchemaHandler") -> "CoreSchema":
+        # double-nested parameterized types here
+        # source_type: List[Union[T,List[...]]]
+        item_type = Any if get_args(get_args(source_type)[0])[0] is _T else get_args(get_args(source_type)[0])[0]
+
+        item_schema = handler.generate_schema(item_type)
+        if item_schema.get("type", "any") != "any":
+            item_schema["strict"] = True
+
+        if item_type is Any:
+            # Before python 3.11, `Any` type was a special object without a __name__
+            item_name = "Any"
+        else:
+            item_name = item_type.__name__
+
+        array_ref = f"any-shape-array-{item_name}"
+
+        schema = core_schema.definitions_schema(
+            core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
+            [
+                core_schema.union_schema(
+                    [
+                        core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
+                        item_schema,
+                    ],
+                    ref=array_ref,
+                )
             ],
         )
-        + ConditionalImport(
-            condition="sys.version_info.minor > 8",
-            module="typing",
-            objects=[ObjectImport(name="Annotated")],
-            alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
-        )
-        + Import(module="pydantic", objects=[ObjectImport(name="GetCoreSchemaHandler")])
-        + Import(module="pydantic_core", objects=[ObjectImport(name="CoreSchema"), ObjectImport(name="core_schema")])
-    )
 
-    # annotated types are special and inspect.getsource() can't stringify them
-    _AnyShapeArrayInjects = [
-        '_T = TypeVar("_T")',
-        '_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]',
-        AnyShapeArrayType,
-        "AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]",
-    ]
+        return schema
 
-else:
 
-    class AnyShapeArray(Generic[_T]):
-        type_: Type[Any] = Any
-
-        def __class_getitem__(cls, item):
-            alias = type(f"AnyShape_{str(item.__name__)}", (AnyShapeArray,), {"type_": item})
-            alias.type_ = item
-            return alias
-
-        @classmethod
-        def __get_validators__(cls):
-            yield cls.validate
-
-        @classmethod
-        def __modify_schema__(cls, field_schema):
-            try:
-                item_type = field_schema["allOf"][0]["type"]
-                type_schema = {"type": item_type}
-                del field_schema["allOf"]
-            except KeyError as e:
-                if "allOf" in str(e):
-                    item_type = "Any"
-                    type_schema = {}
-                else:
-                    raise e
-
-            array_id = f"#any-shape-array-{item_type}"
-            field_schema["anyOf"] = [
-                type_schema,
-                {"type": "array", "items": {"$ref": array_id}},
-            ]
-            field_schema["$id"] = array_id
-
-        @classmethod
-        def validate(cls, v: Union[List[_T], list]):
-            if str(type(v)) == "<class 'numpy.ndarray'>":
-                v = v.tolist()
-
-            if not isinstance(v, list):
-                raise TypeError(f"Must be a list of lists! got {v}")
-
-            def _validate(_v: Union[List[_T], list]):
-                for item in _v:
-                    if isinstance(item, list):
-                        _validate(item)
-                    else:
-                        try:
-                            anytype = cls.type_.__name__ in ("AnyType", "Any")
-                        except AttributeError:
-                            # in python 3.8 and 3.9, `typing.Any` has no __name__
-                            anytype = str(cls.type_).split(".")[-1] in ("AnyType", "Any")
-
-                        if not anytype and not isinstance(item, cls.type_):
-                            raise TypeError(
-                                (
-                                    f"List items must be list of lists, or the type used in "
-                                    f"the subscript ({cls.type_}. Got item {item} and outer value {v}"
-                                )
-                            )
-                return _v
-
-            return _validate(v)
-
-    _AnyShapeArrayImports = Imports() + Import(
+AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]
+
+_AnyShapeArrayImports = (
+    Imports()
+    + Import(
         module="typing",
-        objects=[ObjectImport(name="Generic"), ObjectImport(name="TypeVar"), ObjectImport(name="_GenericAlias")],
+        objects=[
+            ObjectImport(name="Generic"),
+            ObjectImport(name="Iterable"),
+            ObjectImport(name="TypeVar"),
+            ObjectImport(name="Union"),
+            ObjectImport(name="get_args"),
+        ],
     )
-    _AnyShapeArrayInjects = [
-        '_T = TypeVar("_T")',
-        AnyShapeArray,
-    ]
+    + ConditionalImport(
+        condition="sys.version_info.minor > 8",
+        module="typing",
+        objects=[ObjectImport(name="Annotated")],
+        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
+    )
+    + Import(module="pydantic", objects=[ObjectImport(name="GetCoreSchemaHandler")])
+    + Import(module="pydantic_core", objects=[ObjectImport(name="CoreSchema"), ObjectImport(name="core_schema")])
+)
+
+# annotated types are special and inspect.getsource() can't stringify them
+_AnyShapeArrayInjects = [
+    '_T = TypeVar("_T")',
+    '_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]',
+    AnyShapeArrayType,
+    "AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]",
+]
 
 _ConListImports = Imports() + Import(module="pydantic", objects=[ObjectImport(name="conlist")])
 
 
 class ArrayRangeGenerator(ABC):
     """
-    Metaclass for generating a given format of array annotation.
+    Metaclass for generating a given format of array range.
 
     See :ref:`array-forms` for more details on array range forms.
 
@@ -196,23 +130,18 @@ class ArrayRangeGenerator(ABC):
         (unless that's what you intend to do ofc ;)
 
     Attributes:
-        array (:class:`.ArrayExpression` ): Array to create an annotation for
+        array (:class:`.ArrayExpression` ): Array to create a range for
         dtype (Union[str, :class:`.Element` ): dtype of the entire array as a string
-        pydantic_ver (str): Pydantic version to generate array form for -
-            currently only pydantic 1 and 2 are differentiated, and pydantic 1 will be deprecated soon.
 
     """
 
     REPR: ClassVar[ArrayRepresentation]
 
-    def __init__(
-        self, array: Optional[ArrayExpression], dtype: Union[str, Element], pydantic_ver: str = PYDANTIC_VERSION
-    ):
+    def __init__(self, array: Optional[ArrayExpression], dtype: Union[str, Element]):
         self.array = array
         self.dtype = dtype
-        self.pydantic_ver = pydantic_ver
 
-    def make(self) -> SlotResult:
+    def make(self) -> RangeResult:
         """Create the string form of the array representation"""
         if not self.array.dimensions and not self.has_bounded_dimensions:
             # any-shaped array
@@ -238,22 +167,22 @@ class ArrayRangeGenerator(ABC):
         raise ValueError(f"Generator for array representation {repr} not found!")
 
     @abstractmethod
-    def any_shape(self, array: Optional[ArrayRepresentation] = None) -> SlotResult:
+    def any_shape(self, array: Optional[ArrayRepresentation] = None) -> RangeResult:
         """Any shaped array!"""
         pass
 
     @abstractmethod
-    def bounded_dimensions(self, array: ArrayExpression) -> SlotResult:
+    def bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
         """Array shape specified numerically, without axis parameterization"""
         pass
 
     @abstractmethod
-    def parameterized_dimensions(self, array: ArrayExpression) -> SlotResult:
+    def parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
         """Array shape specified with ``dimensions`` without additional parameterized dimensions"""
         pass
 
     @abstractmethod
-    def complex_dimensions(self, array: ArrayExpression) -> SlotResult:
+    def complex_dimensions(self, array: ArrayExpression) -> RangeResult:
         """Array shape with both ``parameterized`` and ``bounded`` dimensions"""
         pass
 
@@ -273,7 +202,7 @@ class ListOfListsArray(ArrayRangeGenerator):
         return ("List[" * dimensions) + dtype + ("]" * dimensions)
 
     @staticmethod
-    def _parameterized_dimension(dimension: DimensionExpression, dtype: str) -> SlotResult:
+    def _parameterized_dimension(dimension: DimensionExpression, dtype: str) -> RangeResult:
         # TODO: Preserve label representation in some readable way! doing the MVP now of using conlist
         if dimension.exact_cardinality and (dimension.minimum_cardinality or dimension.maximum_cardinality):
             raise ValueError("Can only specify EITHER exact_cardinality OR minimum/maximum cardinality")
@@ -285,26 +214,21 @@ class ListOfListsArray(ArrayRangeGenerator):
             dmax = dimension.maximum_cardinality
         else:
             # TODO: handle labels for labeled but unshaped arrays
-            return SlotResult(annotation="List[" + dtype + "]")
+            return RangeResult(range="List[" + dtype + "]")
 
         items = []
-        if int(PYDANTIC_VERSION[0]) >= 2:
-            if dmin is not None:
-                items.append(f"min_length={dmin}")
-            if dmax is not None:
-                items.append(f"max_length={dmax}")
-        else:
-            if dmin is not None:
-                items.append(f"min_items={dmin}")
-            if dmax is not None:
-                items.append(f"max_items={dmax}")
+        if dmin is not None:
+            items.append(f"min_length={dmin}")
+        if dmax is not None:
+            items.append(f"max_length={dmax}")
+
         items.append(f"item_type={dtype}")
         items = ", ".join(items)
-        annotation = f"conlist({items})"
+        range = f"conlist({items})"
 
-        return SlotResult(annotation=annotation, imports=_ConListImports)
+        return RangeResult(range=range, imports=_ConListImports)
 
-    def any_shape(self, array: Optional[ArrayExpression] = None, with_inner_union: bool = False) -> SlotResult:
+    def any_shape(self, array: Optional[ArrayExpression] = None, with_inner_union: bool = False) -> RangeResult:
         """
         An AnyShaped array (using :class:`.AnyShapeArray` )
 
@@ -315,17 +239,17 @@ class ListOfListsArray(ArrayRangeGenerator):
 
         """
         if self.dtype in ("Any", "AnyType"):
-            annotation = "AnyShapeArray"
+            range = "AnyShapeArray"
         else:
-            annotation = f"AnyShapeArray[{self.dtype}]"
+            range = f"AnyShapeArray[{self.dtype}]"
 
         if with_inner_union:
-            annotation = f"Union[{annotation}, {self.dtype}]"
-        return SlotResult(annotation=annotation, injected_classes=_AnyShapeArrayInjects, imports=_AnyShapeArrayImports)
+            range = f"Union[{range}, {self.dtype}]"
+        return RangeResult(range=range, injected_classes=_AnyShapeArrayInjects, imports=_AnyShapeArrayImports)
 
-    def bounded_dimensions(self, array: ArrayExpression) -> SlotResult:
+    def bounded_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
-        A nested series of ``List[]`` annotations 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`` .
         """
@@ -335,29 +259,27 @@ class ListOfListsArray(ArrayRangeGenerator):
             and array.minimum_number_dimensions == array.maximum_number_dimensions
         ):
             exact_dims = array.exact_number_dimensions or array.minimum_number_dimensions
-            return SlotResult(annotation=self._list_of_lists(exact_dims, self.dtype))
+            return RangeResult(range=self._list_of_lists(exact_dims, self.dtype))
         elif not array.maximum_number_dimensions and (
             array.minimum_number_dimensions is None or array.minimum_number_dimensions == 1
         ):
             return self.any_shape()
         elif array.maximum_number_dimensions:
-            # e.g., if min = 2, max = 3, annotation = 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
-            annotations = [
-                self._list_of_lists(i, self.dtype) for i in range(min_dims, array.maximum_number_dimensions + 1)
-            ]
+            ranges = [self._list_of_lists(i, self.dtype) for i in range(min_dims, array.maximum_number_dimensions + 1)]
             # TODO: Format this nicely!
-            return SlotResult(annotation="Union[" + ", ".join(annotations) + "]")
+            return RangeResult(range="Union[" + ", ".join(ranges) + "]")
         else:
             # min specified with no max
-            # e.g., if min = 3, annotation = List[List[AnyShapeArray[dtype]]]
-            return SlotResult(
-                annotation=self._list_of_lists(array.minimum_number_dimensions - 1, self.any_shape().annotation),
+            # 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,
                 imports=_AnyShapeArrayImports,
             )
 
-    def parameterized_dimensions(self, array: ArrayExpression) -> SlotResult:
+    def parameterized_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
         Constrained shapes using :func:`pydantic.conlist`
 
@@ -367,20 +289,20 @@ class ListOfListsArray(ArrayRangeGenerator):
         """
         # generate dimensions from inside out and then format
         # e.g., if dimensions = [{min_card: 3}, {min_card: 2}],
-        # annotation = conlist(min_length=3, item_type=conlist(min_length=2, item_type=dtype))
+        # range = conlist(min_length=3, item_type=conlist(min_length=2, item_type=dtype))
         range = self.dtype
         for dimension in reversed(array.dimensions):
-            range = self._parameterized_dimension(dimension, range).annotation
+            range = self._parameterized_dimension(dimension, range).range
 
-        return SlotResult(annotation=range, imports=_ConListImports)
+        return RangeResult(range=range, imports=_ConListImports)
 
-    def complex_dimensions(self, array: ArrayExpression) -> SlotResult:
+    def complex_dimensions(self, array: ArrayExpression) -> RangeResult:
         """
         Mixture of parameterized dimensions with a max or min (or both) shape for anonymous dimensions.
 
         A mixture of ``List`` , :class:`.conlist` , and :class:`.AnyShapeArray` .
         """
-        # first process any unlabeled dimensions which must be the innermost level of the annotation,
+        # first process any unlabeled dimensions which must be the innermost level of the range,
         # then wrap that with labeled dimensions
         if array.exact_number_dimensions or (
             array.minimum_number_dimensions
@@ -389,7 +311,7 @@ class ListOfListsArray(ArrayRangeGenerator):
         ):
             exact_dims = array.exact_number_dimensions or array.minimum_number_dimensions
             if exact_dims > len(array.dimensions):
-                res = SlotResult(annotation=self._list_of_lists(exact_dims - len(array.dimensions), self.dtype))
+                res = RangeResult(range=self._list_of_lists(exact_dims - len(array.dimensions), self.dtype))
             elif exact_dims == len(array.dimensions):
                 # equivalent to labeled shape
                 return self.parameterized_dimensions(array)
@@ -404,11 +326,9 @@ class ListOfListsArray(ArrayRangeGenerator):
 
             if array.minimum_number_dimensions and array.minimum_number_dimensions > len(array.dimensions):
                 # some minimum anonymous dimensions but unlimited max dimensions
-                # e.g., if min = 3, len(dim) = 2, then res.annotation = List[Union[AnyShapeArray[dtype], dtype]]
-                # res.annotation will be wrapped with the 2 labeled dimensions later
-                res.annotation = self._list_of_lists(
-                    array.minimum_number_dimensions - len(array.dimensions), res.annotation
-                )
+                # 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)
 
         elif array.minimum_number_dimensions and array.maximum_number_dimensions is None:
             raise ValueError(
@@ -431,9 +351,9 @@ class ListOfListsArray(ArrayRangeGenerator):
 
         # Wrap inner dimension with labeled dimension
         # e.g., if dimensions = [{min_card: 3}, {min_card: 2}]
-        # and res.annotation = List[Union[AnyShapeArray[dtype], dtype]]
+        # and res.range = List[Union[AnyShapeArray[dtype], dtype]]
         # (min 3 dims, no max dims)
-        # then the final annotation = conlist(
+        # then the final range = conlist(
         #     min_length=3,
         #     item_type=conlist(
         #         min_length=2,
@@ -441,7 +361,7 @@ class ListOfListsArray(ArrayRangeGenerator):
         #     )
         # )
         for dim in reversed(array.dimensions):
-            res = res.merge(self._parameterized_dimension(dim, dtype=res.annotation))
+            res = res.merge(self._parameterized_dimension(dim, dtype=res.range))
 
         return res
 

linkml/generators/pydanticgen/build.py

@@ -1,20 +1,27 @@
+from pathlib import Path
 from typing import List, Optional, Type, TypeVar, Union
 
-from pydantic import BaseModel
-
-from linkml.generators.pydanticgen.template import Import, Imports
-
-T = TypeVar("T", bound="BuildResult", covariant=True)
-
-
-class BuildResult(BaseModel):
+from linkml.generators.common.build import (
+    BuildResult,
+    SchemaResult,
+)
+from linkml.generators.common.build import (
+    ClassResult as ClassResult_,
+)
+from linkml.generators.common.build import (
+    RangeResult as RangeResult_,
+)
+from linkml.generators.common.build import (
+    SlotResult as SlotResult_,
+)
+from linkml.generators.pydanticgen.template import Import, Imports, PydanticAttribute, PydanticClass
+
+T = TypeVar("T", bound="PydanticBuildResult", covariant=True)
+
+
+class PydanticBuildResult(BuildResult):
     """
-    The result of any build phase for any linkML object
-
-    BuildResults are merged in the serialization process, and are used
-    to keep track of not only the particular representation
-    of the thing in question, but any "side effects" that need to happen
-    elsewhere in the generation process (like adding imports, injecting classes, etc.)
+    BuildResult parent class for pydantic generator
     """
 
     imports: Optional[Union[List[Import], Imports]] = None
@@ -27,39 +34,53 @@ class BuildResult(BaseModel):
         - Merges imports with :meth:`.Imports.__add__`
         - Extends (with simple deduplication) injected classes
 
+        The top-level `merge` method is intended to just merge the "extra" parts of a result
+        - ie. propagating the imports and injected classes up from 'lower' level results.
+        It should *not* be used as a general "merge" method to eg. merge the results of two
+        slot ranges into a Union of those ranges, etc. Either override this method (preserving
+        the base behavior) or put that kind of merging logic into the generator.
+
         .. note::
 
             This returns a (shallow) copy of ``self``, so subclasses don't need to make additional copies.
 
         Args:
-            other (:class:`.BuildResult`): A subclass of BuildResult, generic over whatever we have passed.
+            other (:class:`.PydanticBuildResult`): A subclass of PydanticBuildResult,
+            generic over whatever we have passed.
 
         Returns:
-            :class:`.BuildResult`
+            :class:`.PydanticBuildResult`
         """
-        self_copy = self.copy()
+        self_copy = self.model_copy()
         if other.imports:
             if self.imports is not None:
                 self_copy.imports += other.imports
             else:
                 self_copy.imports = other.imports
         if other.injected_classes:
-            self_copy.injected_classes.extend(other.injected_classes)
-            self_copy.injected_classes = list(dict.fromkeys(self_copy.injected_classes))
+            if self_copy.injected_classes is not None:
+                self_copy.injected_classes.extend(other.injected_classes)
+                self_copy.injected_classes = list(dict.fromkeys(self_copy.injected_classes))
+            else:
+                self_copy.injected_classes = other.injected_classes
         return self_copy
 
 
-class SlotResult(BuildResult):
-    annotation: str
+class RangeResult(PydanticBuildResult, RangeResult_):
+    """
+    The result of building just the range part of a slot
+    """
+
+    range: str
     """The type annotation used in the generated model"""
     field_extras: Optional[dict] = None
     """Additional metadata for this slot to be held in the Field object"""
 
-    def merge(self, other: "SlotResult") -> "SlotResult":
+    def merge(self, other: "RangeResult") -> "RangeResult":
         """
         Merge two SlotResults...
 
-        - calling :meth:`.BuildResult.merge`
+        - calling :meth:`.PydanticBuildResult.merge`
         - replacing the existing annotation with that given by ``other`` .
         - updating any ``field_extras`` with the other
 
@@ -69,11 +90,29 @@ class SlotResult(BuildResult):
         Returns:
             :class:`.SlotResult`
         """
-        res = super(SlotResult, self).merge(other)
+        res = super(RangeResult, self).merge(other)
         # Replace with other's annotation
-        res.annotation = other.annotation
+        res.range = other.range
         if other.field_extras is not None:
             if res.field_extras is None:
                 res.field_extras = {}
             res.field_extras.update(other.field_extras)
         return res
+
+
+class SlotResult(PydanticBuildResult, SlotResult_):
+    attribute: PydanticAttribute
+
+
+class ClassResult(PydanticBuildResult, ClassResult_):
+    cls: PydanticClass
+    """Constructed Template Model for class, including attributes/slots"""
+
+
+class SplitResult(SchemaResult):
+    """Build result when generating with :func:`.generate_split`"""
+
+    main: bool = False
+    path: Path
+    serialized_module: str
+    module_import: Optional[str] = None

linkml/generators/pydanticgen/includes.py

@@ -2,29 +2,7 @@
 Classes to inject in generated pydantic models
 """
 
-from pydantic.version import VERSION
-
-PYDANTIC_VERSION = int(VERSION[0])
-
-
-LinkMLMeta_v1 = """
-class LinkMLMeta(BaseModel):
-    __root__: Dict[str, Any] = {}
-    
-    def __getattr__(self, key:str):
-        return getattr(self.__root__, key)
-        
-    def __getitem__(self, key:str):
-        return self.__root__[key]
-    
-    def __setitem__(self, key:str, value):
-        self.__root__[key] = value
-   
-    class Config:
-        allow_mutation = False
-"""
-
-LinkMLMeta_v2 = """
+LinkMLMeta = """
 class LinkMLMeta(RootModel):
     root: Dict[str, Any] = {}
     model_config = ConfigDict(frozen=True)
@@ -37,10 +15,8 @@ class LinkMLMeta(RootModel):
     
     def __setitem__(self, key:str, value):
         self.root[key] = value
+        
+    def __contains__(self, key:str) -> bool:
+        return key in self.root
     
 """
-
-# if PYDANTIC_VERSION >= 2:
-#     LinkMLMeta = eval(LinkMLMeta_v2)
-# else:
-#     LinkMLMeta = eval(LinkMLMeta_v1)