linkml 1.7.6__py3-none-any.whl → 1.7.7__py3-none-any.whl

linkml/generators/docgen/slot.md.jinja2

@@ -46,14 +46,15 @@ URI: {{ gen.uri_link(element) }}
 <!-- no inheritance hierarchy -->
 {% endif %}
 
-{% if schemaview.get_classes_by_slot(element, include_induced=True) %}
+{% set classes_by_slot = schemaview.get_classes_by_slot(element, include_induced=True) %}
+{% if classes_by_slot %}
 
 ## Applicable Classes
 
 | Name | Description | Modifies Slot |
 | --- | --- | --- |
-{% for c in schemaview.get_classes_by_slot(element, include_induced=True) -%}
-{{ gen.link(c) }} | {{ schemaview.get_class(c).description|enshorten }} | {% if c in schemaview.get_classes_modifying_slot(element) %} yes {% else %} no {% endif %} |
+{% for c in classes_by_slot -%}
+| {{ gen.link(c) }} | {{ schemaview.get_class(c).description|enshorten }} | {% if c in schemaview.get_classes_modifying_slot(element) %} yes {% else %} no {% endif %} |
 {% endfor %}
 
 {% endif %}

linkml/generators/jsonldcontextgen.py

@@ -6,7 +6,7 @@ Generate JSON-LD contexts
 import os
 import re
 from dataclasses import dataclass, field
-from typing import Dict, Optional, Set, Union
+from typing import Any, Dict, Optional, Set, Union
 
 import click
 from jsonasobj2 import JsonObj, as_json
@@ -133,16 +133,13 @@ class ContextGenerator(Generator):
         class_def = {}
         cn = camelcase(cls.name)
         self.add_mappings(cls)
-        cls_uri_prefix, cls_uri_suffix = self.namespaces.prefix_suffix(cls.class_uri)
-        if not self.default_ns or not cls_uri_prefix or cls_uri_prefix != self.default_ns:
-            class_def["@id"] = (cls_uri_prefix + ":" + cls_uri_suffix) if cls_uri_prefix else cls.class_uri
-            if cls_uri_prefix:
-                self.add_prefix(cls_uri_prefix)
+
+        self._build_element_id(class_def, cls.class_uri)
         if class_def:
             self.slot_class_maps[cn] = class_def
 
         # We don't bother to visit class slots - just all slots
-        return False
+        return True
 
     def visit_slot(self, aliased_slot_name: str, slot: SlotDefinition) -> None:
         if slot.identifier:
@@ -169,15 +166,38 @@ class ContextGenerator(Generator):
                         slot_def["@type"] = "@id"
                     else:
                         slot_def["@type"] = range_type.uri
-                slot_prefix = self.namespaces.prefix_for(slot.slot_uri)
-                if not self.default_ns or not slot_prefix or slot_prefix != self.default_ns:
-                    slot_def["@id"] = slot.slot_uri
-                    if slot_prefix:
-                        self.add_prefix(slot_prefix)
+
+                self._build_element_id(slot_def, slot.slot_uri)
                 self.add_mappings(slot)
         if slot_def:
             self.context_body[underscore(aliased_slot_name)] = slot_def
 
+    def _build_element_id(self, definition: Any, uri: str) -> None:
+        """
+        Defines the elements @id attribute according to the default namespace prefix of the schema.
+
+        The @id namespace prefix is added only if it doesn't correspond to the default schema namespace prefix
+        whether it is in URI format or as an alias.
+
+        @param definition: the element (class or slot) definition
+        @param uri: the uri of the element (class or slot)
+        @return: None
+        """
+        uri_prefix, uri_suffix = self.namespaces.prefix_suffix(uri)
+        is_default_namespace = uri_prefix == self.context_body["@vocab"] or uri_prefix == self.namespaces.prefix_for(
+            self.context_body["@vocab"]
+        )
+
+        if not uri_prefix and not uri_suffix:
+            definition["@id"] = uri
+        elif not uri_prefix or is_default_namespace:
+            definition["@id"] = uri_suffix
+        else:
+            definition["@id"] = (uri_prefix + ":" + uri_suffix) if uri_prefix else uri
+
+        if uri_prefix and not is_default_namespace:
+            self.add_prefix(uri_prefix)
+
     def serialize(self, base: Optional[Union[str, Namespace]] = None, **kwargs) -> str:
         return super().serialize(base=base, **kwargs)
 

linkml/generators/owlgen.py

@@ -274,6 +274,8 @@ class OwlSchemaGenerator(Generator):
                 self.graph.add((uri, metaslot_uri, obj))
 
         for k, v in e.annotations.items():
+            if isinstance(v, dict) or isinstance(v, list):
+                continue
             if ":" not in k:
                 default_prefix = this_sv.schema.default_prefix
                 if default_prefix in this_sv.schema.prefixes:

linkml/generators/pydanticgen/array.py

@@ -0,0 +1,457 @@
+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 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
+else:
+    from pydantic import GetCoreSchemaHandler
+    from pydantic_core import CoreSchema, core_schema
+
+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.template import Import, Imports, ObjectImport
+
+
+class ArrayRepresentation(Enum):
+    LIST = "list"
+    NPARRAY = "nparray"  # numpy and nptyping must be installed to use this
+
+
+_BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions", "maximum_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
+            array_ref = f"any-shape-array-{item_type.__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="Annotated"),
+                ObjectImport(name="Generic"),
+                ObjectImport(name="Iterable"),
+                ObjectImport(name="TypeVar"),
+                ObjectImport(name="Union"),
+                ObjectImport(name="get_args"),
+            ],
+        )
+        + 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]",
+    ]
+
+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(
+        module="typing",
+        objects=[ObjectImport(name="Generic"), ObjectImport(name="TypeVar"), ObjectImport(name="_GenericAlias")],
+    )
+    _AnyShapeArrayInjects = [
+        '_T = TypeVar("_T")',
+        AnyShapeArray,
+    ]
+
+_ConListImports = Imports() + Import(module="pydantic", objects=[ObjectImport(name="conlist")])
+
+
+class ArrayRangeGenerator(ABC):
+    """
+    Metaclass for generating a given format of array annotation.
+
+    See :ref:`array-forms` for more details on array range forms.
+
+    These classes do only enough validation of the array specification to decide
+    which kind of representation to generate. Proper value validation should
+    happen elsewhere (ie. in the metamodel and generated :class:`.ArrayExpression` class.)
+
+    Each of the array representation generation methods should be able to handle
+    the supported pydantic versions (currently still 1 and 2).
+
+    Notes:
+
+        When checking for array specification, recall that there is a semantic difference between
+        ``None`` and ``False`` , particularly for :attr:`.ArrayExpression.max_number_dimensions` -
+        check for absence of specification with ``is None`` rather than checking for truthiness/falsiness
+        (unless that's what you intend to do ofc ;)
+
+    Attributes:
+        array (:class:`.ArrayExpression` ): Array to create an annotation 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
+    ):
+        self.array = array
+        self.dtype = dtype
+        self.pydantic_ver = pydantic_ver
+
+    def make(self) -> SlotResult:
+        """Create the string form of the array representation"""
+        if not self.array.dimensions and not self.has_bounded_dimensions:
+            # any-shaped array
+            return self.any_shape(self.array)
+        elif not self.array.dimensions and self.has_bounded_dimensions:
+            return self.bounded_dimensions(self.array)
+        elif self.array.dimensions and not self.has_bounded_dimensions:
+            return self.parameterized_dimensions(self.array)
+        else:
+            return self.complex_dimensions(self.array)
+
+    @property
+    def has_bounded_dimensions(self) -> bool:
+        """Whether the :class:`.ArrayExpression` has some shape specification aside from ``dimensions``"""
+        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"]:
+        """Get the generator class for a given array representation"""
+        for subclass in cls.__subclasses__():
+            if repr in (subclass.REPR, subclass.REPR.value):
+                return subclass
+        raise ValueError(f"Generator for array representation {repr} not found!")
+
+    @abstractmethod
+    def any_shape(self, array: Optional[ArrayRepresentation] = None) -> SlotResult:
+        """Any shaped array!"""
+        pass
+
+    @abstractmethod
+    def bounded_dimensions(self, array: ArrayExpression) -> SlotResult:
+        """Array shape specified numerically, without axis parameterization"""
+        pass
+
+    @abstractmethod
+    def parameterized_dimensions(self, array: ArrayExpression) -> SlotResult:
+        """Array shape specified with ``dimensions`` without additional parameterized dimensions"""
+        pass
+
+    @abstractmethod
+    def complex_dimensions(self, array: ArrayExpression) -> SlotResult:
+        """Array shape with both ``parameterized`` and ``bounded`` dimensions"""
+        pass
+
+
+class ListOfListsArray(ArrayRangeGenerator):
+    """
+    Represent arrays as lists of lists!
+
+    TODO: Move all validation of values (eg. anywhere we raise a ValueError) to the ArrayExpression
+    dataclass and out of the generator class
+    """
+
+    REPR = ArrayRepresentation.LIST
+
+    @staticmethod
+    def _list_of_lists(dimensions: int, dtype: str) -> str:
+        return ("List[" * dimensions) + dtype + ("]" * dimensions)
+
+    @staticmethod
+    def _parameterized_dimension(dimension: DimensionExpression, dtype: str) -> SlotResult:
+        # 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")
+        elif dimension.exact_cardinality:
+            dmin = dimension.exact_cardinality
+            dmax = dimension.exact_cardinality
+        elif dimension.minimum_cardinality or dimension.maximum_cardinality:
+            dmin = dimension.minimum_cardinality
+            dmax = dimension.maximum_cardinality
+        else:
+            # TODO: handle labels for labeled but unshaped arrays
+            return SlotResult(annotation="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}")
+        items.append(f"item_type={dtype}")
+        items = ", ".join(items)
+        annotation = f"conlist({items})"
+
+        return SlotResult(annotation=annotation, imports=_ConListImports)
+
+    def any_shape(self, array: Optional[ArrayExpression] = None, with_inner_union: bool = False) -> SlotResult:
+        """
+        An AnyShaped array (using :class:`.AnyShapeArray` )
+
+        Args:
+            array (:class:`.ArrayExpression`): The array expression (not used)
+            with_inner_union (bool): If ``True`` , the innermost type is a ``Union`` of the ``AnyShapeArray`` class
+                and ``dtype`` (default: ``False`` )
+
+        """
+        if self.dtype in ("Any", "AnyType"):
+            annotation = "AnyShapeArray"
+        else:
+            annotation = f"AnyShapeArray[{self.dtype}]"
+
+        if with_inner_union:
+            annotation = f"Union[{annotation}, {self.dtype}]"
+        return SlotResult(annotation=annotation, injected_classes=_AnyShapeArrayInjects, imports=_AnyShapeArrayImports)
+
+    def bounded_dimensions(self, array: ArrayExpression) -> SlotResult:
+        """
+        A nested series of ``List[]`` annotations 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`` .
+        """
+        if array.exact_number_dimensions or (
+            array.minimum_number_dimensions
+            and array.maximum_number_dimensions
+            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))
+        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]]]]
+            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)
+            ]
+            # TODO: Format this nicely!
+            return SlotResult(annotation="Union[" + ", ".join(annotations) + "]")
+        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),
+                injected_classes=_AnyShapeArrayInjects,
+                imports=_AnyShapeArrayImports,
+            )
+
+    def parameterized_dimensions(self, array: ArrayExpression) -> SlotResult:
+        """
+        Constrained shapes using :func:`pydantic.conlist`
+
+        TODO:
+        - preservation of aliases
+        - (what other metadata is allowable on labeled dimensions?)
+        """
+        # 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 = self.dtype
+        for dimension in reversed(array.dimensions):
+            range = self._parameterized_dimension(dimension, range).annotation
+
+        return SlotResult(annotation=range, imports=_ConListImports)
+
+    def complex_dimensions(self, array: ArrayExpression) -> SlotResult:
+        """
+        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,
+        # then wrap that with labeled dimensions
+        if array.exact_number_dimensions or (
+            array.minimum_number_dimensions
+            and array.maximum_number_dimensions
+            and array.minimum_number_dimensions == array.maximum_number_dimensions
+        ):
+            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))
+            elif exact_dims == len(array.dimensions):
+                # equivalent to labeled shape
+                return self.parameterized_dimensions(array)
+            else:
+                raise ValueError(
+                    "if exact_number_dimensions is provided, it must be greater than the parameterized dimensions"
+                )
+
+        elif array.maximum_number_dimensions is not None and not array.maximum_number_dimensions:
+            # unlimited n dimensions, so innermost is AnyShape with dtype
+            res = self.any_shape(with_inner_union=True)
+
+            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
+                )
+
+        elif array.minimum_number_dimensions and array.maximum_number_dimensions is None:
+            raise ValueError(
+                (
+                    "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"
+                )
+            )
+        elif array.maximum_number_dimensions:
+            initial_min = array.minimum_number_dimensions if array.minimum_number_dimensions is not None else 0
+            dmin = max(len(array.dimensions), initial_min) - len(array.dimensions)
+            dmax = array.maximum_number_dimensions - len(array.dimensions)
+
+            res = self.bounded_dimensions(
+                ArrayExpression(minimum_number_dimensions=dmin, maximum_number_dimensions=dmax)
+            )
+        else:
+            raise ValueError("Unsupported array specification! this is almost certainly a bug!")  # pragma: no cover
+
+        # Wrap inner dimension with labeled dimension
+        # e.g., if dimensions = [{min_card: 3}, {min_card: 2}]
+        # and res.annotation = List[Union[AnyShapeArray[dtype], dtype]]
+        # (min 3 dims, no max dims)
+        # then the final annotation = conlist(
+        #     min_length=3,
+        #     item_type=conlist(
+        #         min_length=2,
+        #         item_type=List[Union[AnyShapeArray[dtype], dtype]]
+        #     )
+        # )
+        for dim in reversed(array.dimensions):
+            res = res.merge(self._parameterized_dimension(dim, dtype=res.annotation))
+
+        return res
+
+
+class NPTypingArray(ArrayRangeGenerator):
+    """
+    Represent array range with nptyping, and serialization/loading with an ArrayProxy
+    """
+
+    REPR = ArrayRepresentation.NPARRAY
+
+    def __init__(self, **kwargs):
+        super(self).__init__(**kwargs)
+        raise NotImplementedError("NPTyping array ranges are not implemented yet :(")

linkml/generators/pydanticgen/black.py

@@ -0,0 +1,29 @@
+"""
+Utilities for formatting pydanticgen outputs
+
+Kept separate in case we decide we don't want it/we want it to be moved to a place
+that's better for other generators to use.
+"""
+
+from typing import Optional
+
+try:
+    from black import Mode, TargetVersion, format_str
+except ImportError:
+    import warnings
+
+    warnings.warn("Black is an optional dependency, install it with the extra 'black' like `pip install linkml[black]`")
+
+
+def _default_mode() -> "Mode":
+    return Mode(
+        target_versions={TargetVersion.PY311},
+    )
+
+
+def format_black(code: str, mode: Optional["Mode"] = None) -> str:
+    if mode is None:
+        mode = _default_mode()
+
+    formatted = format_str(code, mode=mode)
+    return formatted

linkml/generators/pydanticgen/build.py

@@ -0,0 +1,79 @@
+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):
+    """
+    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.)
+    """
+
+    imports: Optional[Union[List[Import], Imports]] = None
+    injected_classes: Optional[List[Union[str, Type]]] = None
+
+    def merge(self, other: T) -> T:
+        """
+        Merge a build result with another.
+
+        - Merges imports with :meth:`.Imports.__add__`
+        - Extends (with simple deduplication) injected classes
+
+        .. 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.
+
+        Returns:
+            :class:`.BuildResult`
+        """
+        self_copy = self.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))
+        return self_copy
+
+
+class SlotResult(BuildResult):
+    annotation: 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":
+        """
+        Merge two SlotResults...
+
+        - calling :meth:`.BuildResult.merge`
+        - replacing the existing annotation with that given by ``other`` .
+        - updating any ``field_extras`` with the other
+
+        Args:
+            other (:class:`.SlotResult`): The other slot result to merge!
+
+        Returns:
+            :class:`.SlotResult`
+        """
+        res = super(SlotResult, self).merge(other)
+        # Replace with other's annotation
+        res.annotation = other.annotation
+        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

linkml/generators/pydanticgen/pydanticgen.py

@@ -1,17 +1,24 @@
 import inspect
 import logging
 import os
+import textwrap
 from collections import defaultdict
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from types import ModuleType
-from typing import Dict, List, Literal, Optional, Set, Type, Union
+from typing import (
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Set,
+    Type,
+    Union,
+)
 
 import click
 from jinja2 import ChoiceLoader, Environment, FileSystemLoader
-
-# from linkml.generators import pydantic_GEN_VERSION
 from linkml_runtime.linkml_model.meta import (
     Annotation,
     ClassDefinition,
@@ -30,6 +37,8 @@ from linkml.generators.common.type_designators import (
     get_type_designator_value,
 )
 from linkml.generators.oocodegen import OOCodeGenerator
+from linkml.generators.pydanticgen.array import ArrayRangeGenerator, ArrayRepresentation
+from linkml.generators.pydanticgen.build import SlotResult
 from linkml.generators.pydanticgen.template import (
     ConditionalImport,
     Import,
@@ -111,6 +120,11 @@ class PydanticGenerator(OOCodeGenerator):
     file_extension = "py"
 
     # ObjectVars
+    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
+    """
     pydantic_version: int = int(PYDANTIC_VERSION[0])
     template_dir: Optional[Union[str, Path]] = None
     """
@@ -491,7 +505,22 @@ class PydanticGenerator(OOCodeGenerator):
             env.loader = loader
         return env
 
-    def serialize(self) -> str:
+    def get_array_representations_range(self, slot: SlotDefinition, range: str) -> List[SlotResult]:
+        """
+        Generate the python range for array representations
+        """
+        array_reps = []
+        for repr in self.array_representations:
+            generator = ArrayRangeGenerator.get_generator(repr)
+            result = generator(slot.array, range, self.pydantic_version).make()
+            array_reps.append(result)
+
+        if len(array_reps) == 0:
+            raise ValueError("No array representation generated, but one was requested!")
+
+        return array_reps
+
+    def render(self) -> PydanticModule:
         sv: SchemaView
         sv = self.schemaview
         schema = sv.schema
@@ -501,6 +530,9 @@ class PydanticGenerator(OOCodeGenerator):
             description=schema.description.replace('"', '\\"') if schema.description else None,
         )
         enums = self.generate_enums(sv.all_enums())
+        injected_classes = []
+        if self.injected_classes is not None:
+            injected_classes += self.injected_classes
 
         imports = DEFAULT_IMPORTS
         if self.imports is not None:
@@ -559,10 +591,20 @@ class PydanticGenerator(OOCodeGenerator):
                 else:
                     raise Exception(f"Could not generate python range for {class_name}.{s.name}")
 
-                if "linkml:elements" in s.implements:
+                if s.array is not None:
                     # TODO add support for xarray
-                    pyrange = "np.ndarray"
-                    imports += Import(module="numpy", alias="np")
+                    results = self.get_array_representations_range(s, pyrange)
+                    # TODO: Move results unpacking to own function that is used after each slot build stage :)
+                    for res in results:
+                        if res.injected_classes:
+                            injected_classes += res.injected_classes
+                        if res.imports:
+                            imports += res.imports
+                    if len(results) == 1:
+                        pyrange = results[0].annotation
+                    else:
+                        pyrange = f"Union[{', '.join([res.annotation for res in results])}]"
+
                     if "linkml:ColumnOrderedArray" in class_def.implements:
                         raise NotImplementedError("Cannot generate Pydantic code for ColumnOrderedArrays.")
                 elif s.multivalued:
@@ -586,10 +628,11 @@ class PydanticGenerator(OOCodeGenerator):
                 ann = Annotation("python_range", pyrange)
                 s.annotations[ann.tag] = ann
 
-        if self.injected_classes is not None:
-            injected_classes = [c if isinstance(c, str) else inspect.getsource(c) for c in self.injected_classes]
-        else:
-            injected_classes = None
+        # TODO: Make cleaning injected classes its own method
+        injected_classes = list(
+            dict.fromkeys([c if isinstance(c, str) else inspect.getsource(c) for c in injected_classes])
+        )
+        injected_classes = [textwrap.dedent(c) for c in injected_classes]
 
         base_model = PydanticBaseModel(
             pydantic_ver=self.pydantic_version, extra_fields=self.extra_fields, fields=self.injected_fields
@@ -630,8 +673,11 @@ class PydanticGenerator(OOCodeGenerator):
             enums=enums,
             classes=classes,
         )
-        code = module.render(self._template_environment())
-        return code
+        return module
+
+    def serialize(self) -> str:
+        module = self.render()
+        return module.render(self._template_environment(), self.black)
 
     def default_value_for_type(self, typ: str) -> str:
         return "None"
@@ -669,6 +715,13 @@ Available templates to override:
     default=1,
     help="Pydantic version to use (1 or 2)",
 )
+@click.option(
+    "--array-representations",
+    type=click.Choice([k.value for k in ArrayRepresentation]),
+    multiple=True,
+    default=["list"],
+    help="List of array representations to accept for array slots. Default is list of lists.",
+)
 @click.option(
     "--extra-fields",
     type=click.Choice(["allow", "ignore", "forbid"], case_sensitive=False),
@@ -685,8 +738,9 @@ def cli(
     genmeta=False,
     classvars=True,
     slots=True,
+    array_representations=list("list"),
     pydantic_version=1,
-    extra_fields="forbid",
+    extra_fields: Literal["allow", "forbid", "ignore"] = "forbid",
     **args,
 ):
     """Generate pydantic classes to represent a LinkML model"""
@@ -705,6 +759,7 @@ def cli(
     gen = PydanticGenerator(
         yamlfile,
         pydantic_version=pydantic_version,
+        array_representations=[ArrayRepresentation(x) for x in array_representations],
         extra_fields=extra_fields,
         emit_metadata=head,
         genmeta=genmeta,

linkml/generators/pydanticgen/template.py

@@ -1,14 +1,24 @@
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generator, List, Literal, Optional, Union, overload
+from importlib.util import find_spec
+from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Union, overload
 
 from jinja2 import Environment, PackageLoader
 from pydantic import BaseModel, Field
 from pydantic.version import VERSION as PYDANTIC_VERSION
 
+try:
+    if find_spec("black") is not None:
+        from linkml.generators.pydanticgen.black import format_black
+    else:
+        # no warning, having black is optional, we only warn when someone tries to import it explicitly
+        format_black = None
+except ImportError:
+    # we can also get an import error from find_spec during testing because that's how we mock not having it installed
+    format_black = None
+
 if int(PYDANTIC_VERSION[0]) >= 2:
     from pydantic import computed_field
 else:
-    if TYPE_CHECKING:  # pragma: no cover
-        from pydantic.fields import ModelField
+    from pydantic.fields import ModelField
 
 
 class TemplateModel(BaseModel):
@@ -22,12 +32,31 @@ class TemplateModel(BaseModel):
     to already be rendered to strings - ie. rather than the ``class.py.jinja``
     template receiving a full :class:`.PydanticAttribute` object or dictionary,
     it receives it having already been rendered to a string. See the :meth:`.render` method.
+
+    .. admonition:: Black Formatting
+
+        Template models will try to use ``black`` to format results when it is available in the
+        environment when render is called with ``black = True`` . If it isn't, then the string is
+        returned without any formatting beyond the template.
+        This is mostly important for complex annotations like those produced for arrays,
+        as otherwise the templates are acceptable looking.
+
+        To install linkml with black, use the extra ``black`` dependency.
+
+        e.g. with pip::
+
+            pip install linkml[black]
+
+        or with poetry::
+
+            poetry install -E black
+
     """
 
     template: ClassVar[str]
     pydantic_ver: int = int(PYDANTIC_VERSION[0])
 
-    def render(self, environment: Optional[Environment] = None) -> str:
+    def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
         """
         Recursively render a template model to a string.
 
@@ -35,6 +64,10 @@ class TemplateModel(BaseModel):
         using the template set in :attr:`.TemplateModel.template` , but preserving the structure
         of lists and dictionaries. Regular :class:`.BaseModel` s are rendered to dictionaries.
         Any other value is passed through unchanged.
+
+        Args:
+            environment (:class:`jinja2.Environment`): Template environment - see :meth:`.environment`
+            black (bool): if ``True`` , format template with black. (default False)
         """
         if environment is None:
             environment = TemplateModel.environment()
@@ -46,7 +79,17 @@ class TemplateModel(BaseModel):
 
         data = {k: _render(getattr(self, k, None), environment) for k in fields}
         template = environment.get_template(self.template)
-        return template.render(**data)
+        rendered = template.render(**data)
+        if format_black is not None and black:
+            try:
+                return format_black(rendered)
+            except Exception:
+                # TODO: it would nice to have a standard logging module here ;)
+                return rendered
+        elif black and format_black is None:
+            raise ValueError("black formatting was requested, but black is not installed in this environment")
+        else:
+            return rendered
 
     @classmethod
     def environment(cls) -> Environment:
@@ -148,6 +191,17 @@ class PydanticBaseModel(TemplateModel):
     Extra fields that are typically injected into the base model via
     :attr:`~linkml.generators.pydanticgen.PydanticGenerator.injected_fields`
     """
+    strict: bool = False
+    """
+    Enable strict mode in the base model.
+    
+    .. note::
+    
+        Pydantic 2 only! Pydantic 1 only has strict types, not strict mode. See: https://github.com/linkml/linkml/issues/1955
+    
+    References:
+        https://docs.pydantic.dev/latest/concepts/strict_mode
+    """
 
 
 class PydanticAttribute(TemplateModel):
@@ -252,11 +306,11 @@ class PydanticClass(TemplateModel):
             super(PydanticClass, self).__init__(**kwargs)
             self.validators = self._validators()
 
-        def render(self, environment: Optional[Environment] = None) -> str:
+        def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
             """Overridden in pydantic 1 to ensure that validators are regenerated at rendering time"""
             # refresh in case attributes have changed since init
             self.validators = self._validators()
-            return super(PydanticClass, self).render(environment)
+            return super(PydanticClass, self).render(environment, black)
 
 
 class ObjectImport(BaseModel):
@@ -320,6 +374,10 @@ class Import(TemplateModel):
             return [self, other]
 
         # handle conditionals
+        if isinstance(self, ConditionalImport) and isinstance(other, ConditionalImport):
+            # If our condition is the same, return the newer version
+            if self.condition == other.condition:
+                return [other]
         if isinstance(self, ConditionalImport) or isinstance(other, ConditionalImport):
             # we don't have a good way of combining conditionals, just return both
             return [self, other]
@@ -430,9 +488,20 @@ class Imports(TemplateModel):
 
     imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
 
-    def __add__(self, other: Import) -> "Imports":
+    def __add__(self, other: Union[Import, "Imports", List[Import]]) -> "Imports":
+        if isinstance(other, Imports) or (isinstance(other, list) and all([isinstance(i, Import) for i in other])):
+            if hasattr(self, "model_copy"):
+                self_copy = self.model_copy(deep=True)
+            else:
+                self_copy = self.copy()
+
+            for i in other:
+                self_copy += i
+            return self_copy
+
         # check if we have one of these already
         imports = self.imports.copy()
+
         existing = [i for i in imports if i.module == other.module]
 
         # if we have nothing importing from this module yet, add it!
@@ -454,6 +523,10 @@ class Imports(TemplateModel):
                         merged = e.merge(other)
                         imports.extend(merged)
                         break
+
+        # SPECIAL CASE - __future__ annotations must happen at the top of a file
+        imports = sorted(imports, key=lambda i: i.module == "__future__", reverse=True)
+
         return Imports(imports=imports)
 
     def __len__(self) -> int:
@@ -495,10 +568,10 @@ class PydanticModule(TemplateModel):
             super(PydanticModule, self).__init__(**kwargs)
             self.class_names = [c.name for c in self.classes.values()]
 
-        def render(self, environment: Optional[Environment] = None) -> str:
+        def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
             """
             Trivial override of parent method for pydantic 1 to ensure that
             :attr:`.class_names` are correct at render time
             """
             self.class_names = [c.name for c in self.classes.values()]
-            return super(PydanticModule, self).render(environment)
+            return super(PydanticModule, self).render(environment, black)

linkml/generators/pydanticgen/templates/base_model.py.jinja

@@ -16,7 +16,9 @@ class {{ name }}(BaseModel):
         validate_default = True,
         extra = "{{ extra_fields }}",
         arbitrary_types_allowed = True,
-        use_enum_values = True)
+        use_enum_values = True,
+        strict = {{ strict }},
+    )
 {% endif %}
 {% if fields is not none %}
     {% for field in fields %}

linkml/generators/shacl/ifabsent_processor.py

@@ -1,5 +1,5 @@
 import re
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model import SlotDefinition
@@ -10,21 +10,34 @@ from linkml.generators.shacl.shacl_data_type import ShaclDataType
 
 
 class IfAbsentProcessor:
+    """
+    Processes value of ifabsent slot.
+
+    See `<https://w3id.org/linkml/ifabsent>`_.
+
+    TODO: unify this with ifabsent_functions
+    """
 
     ifabsent_regex = re.compile("""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
 
     def __init__(self, schema_view: SchemaView):
         self.schema_view = schema_view
 
-    def process_slot(self, add_prop: Callable[[URIRef, Identifier], None], slot: SlotDefinition):
+    def process_slot(
+        self, add_prop: Callable[[URIRef, Identifier], None], slot: SlotDefinition, class_uri: Optional[URIRef] = None
+    ) -> None:
         if slot.ifabsent:
             ifabsent_match = self.ifabsent_regex.search(slot.ifabsent)
             ifabsent_default_value = ifabsent_match.group("default_value")
 
-            self._map_to_default_value(slot, add_prop, ifabsent_default_value)
+            self._map_to_default_value(slot, add_prop, ifabsent_default_value, class_uri)
 
     def _map_to_default_value(
-        self, slot: SlotDefinition, add_prop: Callable[[URIRef, Identifier], None], ifabsent_default_value: Any
+        self,
+        slot: SlotDefinition,
+        add_prop: Callable[[URIRef, Identifier], None],
+        ifabsent_default_value: Any,
+        class_uri: Optional[URIRef] = None,
     ) -> None:
         for datatype in list(ShaclDataType):
             if datatype.linkml_type == slot.range:
@@ -38,4 +51,9 @@ class IfAbsentProcessor:
                         add_prop(SH.defaultValue, Literal(ifabsent_default_value))
                         return
 
+        if ifabsent_default_value == "class_curie":
+            if class_uri:
+                add_prop(SH.defaultValue, class_uri)
+            return
+
         raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")

linkml/generators/shaclgen.py

@@ -162,7 +162,7 @@ class ShaclGenerator(Generator):
                         if sv.get_identifier_slot(r) is not None:
                             prop_pv(SH.nodeKind, SH.IRI)
                         else:
-                            prop_pv(SH.nodeKind, SH.BlankNode)
+                            prop_pv(SH.nodeKind, SH.BlankNodeOrIRI)
                     elif r in sv.all_types().values():
                         self._add_type(prop_pv, r)
                     elif r in sv.all_enums():
@@ -172,7 +172,7 @@ class ShaclGenerator(Generator):
                     if s.pattern:
                         prop_pv(SH.pattern, Literal(s.pattern))
 
-                ifabsent_processor.process_slot(prop_pv, s)
+                ifabsent_processor.process_slot(prop_pv, s, class_uri)
 
         return g
 

linkml/utils/generator.py

@@ -684,7 +684,7 @@ class Generator(metaclass=abc.ABCMeta):
 
     def slot_name(self, name: str) -> str:
         """
-        Return the underscored version of the aliased slot name if name is a slot. Prepend "unknown\_" if the name
+        Return the underscored version of the aliased slot name if name is a slot. Prepend ``unknown_`` if the name
         isn't valid.
         """
         slot = self.slot_for(name)

{linkml-1.7.6.dist-info → linkml-1.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.7.6
+Version: 1.7.7
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -19,12 +19,15 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: black
 Provides-Extra: shacl
 Provides-Extra: tests
 Requires-Dist: antlr4-python3-runtime (>=4.9.0,<4.10)
+Requires-Dist: black (>=24.0.0) ; extra == "black" or extra == "tests"
 Requires-Dist: click (>=7.0)
 Requires-Dist: graphviz (>=0.10.1)
 Requires-Dist: hbreader
@@ -33,11 +36,11 @@ Requires-Dist: jinja2 (>=3.1.0)
 Requires-Dist: jsonasobj2 (>=1.0.3,<2.0.0)
 Requires-Dist: jsonschema[format] (>=4.0.0)
 Requires-Dist: linkml-dataops
-Requires-Dist: linkml-runtime (>=1.7.0)
+Requires-Dist: linkml-runtime (>=1.7.4)
 Requires-Dist: openpyxl
 Requires-Dist: parse
 Requires-Dist: prefixcommons (>=0.1.7)
-Requires-Dist: prefixmaps (>=0.1.3)
+Requires-Dist: prefixmaps (>=0.2.2)
 Requires-Dist: pydantic (>=1.0.0,<3.0.0)
 Requires-Dist: pyjsg (>=0.11.6)
 Requires-Dist: pyshacl (>=0.25.0,<0.26.0) ; extra == "shacl" or extra == "tests"
@@ -48,7 +51,6 @@ Requires-Dist: pyyaml
 Requires-Dist: rdflib (>=6.0.0)
 Requires-Dist: requests (>=2.22)
 Requires-Dist: sqlalchemy (>=1.4.31)
-Requires-Dist: typing-extensions (>=4.5.0,<5.0.0) ; python_version == "3.7"
 Requires-Dist: watchdog (>=0.9.0)
 Project-URL: Documentation, https://linkml.io/linkml/
 Project-URL: Repository, https://github.com/linkml/linkml

{linkml-1.7.6.dist-info → linkml-1.7.7.dist-info}/RECORD

@@ -13,7 +13,7 @@ linkml/generators/docgen/enum.md.jinja2,sha256=mXnUrRkleY2bOTEyAZ5c4pcUnqhs6BNa8
 linkml/generators/docgen/index.md.jinja2,sha256=wXUYTmayPLFltC0vbGE_Mf6m3GkkWav7FOEjCvEpHp4,1466
 linkml/generators/docgen/index.tex.jinja2,sha256=Go_EA-_N4JUpbOYbk3OY11mz5yV70VF2l2sMtgIPWw4,501
 linkml/generators/docgen/schema.md.jinja2,sha256=xlENfnzNRYgPT_0tdqNFxgklVM4Qf5BuzhFVvSMDuxs,70
-linkml/generators/docgen/slot.md.jinja2,sha256=HcLu32FiyIRy0AaV-GwBPUwEbTCY-KkPDhOZk3OKfqg,3226
+linkml/generators/docgen/slot.md.jinja2,sha256=ZGa-kaNvi5LknvFRIjKQyRpSynr1SlkLrpEmWDNPwDA,3226
 linkml/generators/docgen/subset.md.jinja2,sha256=fTNIpAkml5RKFbbtLore3IAzFN1cISVsyL1ru2-Z4oA,2665
 linkml/generators/docgen/type.md.jinja2,sha256=QmCMJZrFwP33eHkggBVtypbyrxTb-XZn9vHOYojVaYk,635
 linkml/generators/docgen.py,sha256=dz7OWxclX306EweVIgC765h3NKtJTRg0TPnqmltWygs,34347
@@ -26,7 +26,7 @@ linkml/generators/graphqlgen.py,sha256=6qZpI0rwg3ypsv_KrLVzXgdsJfR8LNPqgMwaRwzwn
 linkml/generators/javagen/example_template.java.jinja2,sha256=ec4CVTv_0zS7V5Y-1E6H4lRraya10gfX7BEMBlu38X4,444
 linkml/generators/javagen/java_record_template.jinja2,sha256=OQZffLSy_xR3FIhQMltvrYyVeut7l2Q-tzK7AOiVmWs,1729
 linkml/generators/javagen.py,sha256=KxwupMztyCRHcSsbtTnOovuj1WamsAny0mxbYWvTiDs,5324
-linkml/generators/jsonldcontextgen.py,sha256=048kzs28xooik86A8OQ0NIbXxyJZGkqH1ZMxg17mcf4,8073
+linkml/generators/jsonldcontextgen.py,sha256=N_XWCx_1eS5KcWlzlyl79C-dW0gfe32v886UskD1iTU,8644
 linkml/generators/jsonldgen.py,sha256=pk8Gmh2gSvXt_o7MTuJ71thNfIJuHUGkNl3yl3RIdsE,7728
 linkml/generators/jsonschemagen.py,sha256=XOsYIrpA6BwtAcfh8GNGduIjpuPAsF2f_PQ1mghj_WU,27455
 linkml/generators/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -34,16 +34,19 @@ linkml/generators/linkmlgen.py,sha256=1_Kt_7rD42WvCTjq0yaq1Of7jEDZR_uusyzAT-qWMH
 linkml/generators/markdowngen.py,sha256=dDMyusNXLvM2raIW-_vd2AQBhDHn0P_rMeDq3QFuacs,32926
 linkml/generators/namespacegen.py,sha256=vVcIyM0zlKd7XRvtdzwTwHjG4Pg49801gy4FUmjJlqQ,6450
 linkml/generators/oocodegen.py,sha256=r73QI08ajbTZTobc9OIG6BMWZft3zdu76vKVR33pyYg,7774
-linkml/generators/owlgen.py,sha256=FMzdiK85CND8wnLiXPmylpayUTGpuydgD_g4hFjyez4,54374
+linkml/generators/owlgen.py,sha256=NqEvuJOUh4ZEe5tVeVol3SHy7zpCagEhso7Q1GLyIqY,54458
 linkml/generators/plantumlgen.py,sha256=tk-_XJtBA5EqYJSUTc3bdMdCwqlC-rc9VYO9A2V_HpM,14895
 linkml/generators/prefixmapgen.py,sha256=L9TccwKNHEguW0ox5qgf_GhIuqauYTI8d4jSjeqdkWo,4720
 linkml/generators/projectgen.py,sha256=OuT_AneoZFNMCn50GllfZafadUHt50u61JcftM2eed4,9750
 linkml/generators/protogen.py,sha256=5UxThsFDVyDTzzTDh77Z0anx4-tLgz8kQQ-e7ywIqwI,2290
 linkml/generators/pydanticgen/__init__.py,sha256=uKGaaQSaeKqinHImXGFE448i-t8Oi0No8suIO76sep8,629
-linkml/generators/pydanticgen/pydanticgen.py,sha256=ZUi9fE5ZiQbW5V4Ckth8hysMghHh9H2RpqLZa3m8PfQ,27598
-linkml/generators/pydanticgen/template.py,sha256=e2PYQFRlDR1Nva_xy-NlsttpW79L8n6e63QKHZzoXH8,17016
+linkml/generators/pydanticgen/array.py,sha256=imbHtwgQcz_uloFWDBDojIMydZw9eysQyQl6ppT5eL8,19045
+linkml/generators/pydanticgen/black.py,sha256=c-Hgaao9hd4nPMU9w0Hmg2j4Wc81IcY0zAfppQPr1cM,721
+linkml/generators/pydanticgen/build.py,sha256=Ia8qy4C16b-KqO_fw4tGQW_Eo4grCVyX7RsuJ3uRTtk,2681
+linkml/generators/pydanticgen/pydanticgen.py,sha256=psEdNy_oJqHnTBZkQp4H8pNrFXv_y92j5oEoFcp_AEU,29809
+linkml/generators/pydanticgen/template.py,sha256=7I-qch_vr1elXwJ1kxRcZEl3j6-WTLYRh8_b2DjxjyE,19911
 linkml/generators/pydanticgen/templates/attribute.py.jinja,sha256=AlH_QFJJkONpzXQRGqnW4ufmjp9s9E7Q9W5r8ykNGeQ,443
-linkml/generators/pydanticgen/templates/base_model.py.jinja,sha256=eYKNI-4itB6lYW5yhfIWngtMcHZnuEaic9Dv56XKX4M,797
+linkml/generators/pydanticgen/templates/base_model.py.jinja,sha256=48y64MnC9rjNSV-nKLMeDuHN4gm15UsInhnKxh65zoM,834
 linkml/generators/pydanticgen/templates/class.py.jinja,sha256=RIdkqdZS9rDILUuVqDIAWK_vATGkirLbPhdHSyHDAbY,565
 linkml/generators/pydanticgen/templates/conditional_import.py.jinja,sha256=YheknDrxvepiJUzeItSL5aSbAkCdR1k0a6m6aTA4qNM,240
 linkml/generators/pydanticgen/templates/enum.py.jinja,sha256=572XFQyEMZfL-G_Cj68T-NI_mUnDoFOAVJOGIKu2Hb8,338
@@ -54,9 +57,9 @@ linkml/generators/pydanticgen/templates/validator.py.jinja,sha256=Yo4dubQal-HwEo
 linkml/generators/pythongen.py,sha256=AvOQZJ-OT8lMYeaT2bdexHuRPRfTK7wpbmgAdfc2lW4,52805
 linkml/generators/rdfgen.py,sha256=L6F08iDUqVemXXrRbJmcOxvJTt14hR0oo8WLoqf4npw,2656
 linkml/generators/shacl/__init__.py,sha256=O-M-wndKw8rMW-U8X3QCNHal-ErXP6uXZqxiQSa77l4,108
-linkml/generators/shacl/ifabsent_processor.py,sha256=I7zvSjZzB7tZjcXRE0UE3DUmF5sY7QrKbXblYvpRwkc,1746
+linkml/generators/shacl/ifabsent_processor.py,sha256=kV9BGA2ZPXLRfaFuW0o4jpkATvGggvrqpAo9c1UqWNE,2193
 linkml/generators/shacl/shacl_data_type.py,sha256=BT3C9tdFyBQnuucPN7YQiFAKEa9yuzy-Q26X6dmOXgo,1827
-linkml/generators/shaclgen.py,sha256=mTkHziEIKoMTr-Vl6nwOdqxk-97cJzTsFG7ViMiFhMs,8308
+linkml/generators/shaclgen.py,sha256=vCNAX15wg0h86ZplRjo721_58UHUSVHkQULTYV_1HZI,8324
 linkml/generators/shexgen.py,sha256=KzhaL-A4R4peSdhY6nlDWmS-DPfnZMxMzrXhHGnA_Ag,9874
 linkml/generators/sparqlgen.py,sha256=c7x8GFChKWprBx4rToSnu9qN8OleWTCenVUdZ8XSTWM,6138
 linkml/generators/sqlalchemy/__init__.py,sha256=mb9AC1rIFkSiNZhhG0TAk45ol9PjS1XvsrvCjgfVUpQ,249
@@ -100,7 +103,7 @@ linkml/utils/converter.py,sha256=snAF-pgZBSi4ANiaKXxqtZk5w3qonJjTfI4X5OVLmUE,628
 linkml/utils/datautils.py,sha256=QlbzwXykh5Fphfe5KxPo6_ekXfniLbHiEGJtLWjUrvY,3742
 linkml/utils/datavalidator.py,sha256=kBdWaVi8IZT1bOwEJgJYx-wZAb_PTBObB9nHpYORfKA,472
 linkml/utils/execute_tutorial.py,sha256=T4kHTSyz3ItJGEUZxVjR-3yLVKnOr5Ix4NMGE47-IuE,6912
-linkml/utils/generator.py,sha256=8-5JpMmvkWyLMeK5qSRv3XuOpfAmi2quNQ4Mo6nNCA0,38362
+linkml/utils/generator.py,sha256=3q_PpZQxBTwpoN8lHHMkUhHm1gg0qXhiHgLWV9FIVLM,38363
 linkml/utils/helpers.py,sha256=yR8n4zFA5wPcYC7xzRuNF3wO16vG80v6j7DM3qTNmIc,447
 linkml/utils/ifabsent_functions.py,sha256=IkcBcmRYu8sllx7_mTCqu4aHfTxX2AnQoccZ1KOODds,5843
 linkml/utils/logictools.py,sha256=GSmBiobC49TcQjE08RtXEE3JwJEOV7eEREio25uJiFs,21184
@@ -138,8 +141,8 @@ linkml/workspaces/datamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 linkml/workspaces/datamodel/workspaces.py,sha256=4HdkqweGNfMPqnB1_Onc9DcTfkhoagTRcqruh08nRoI,14905
 linkml/workspaces/datamodel/workspaces.yaml,sha256=EjVrwPpeRZqJRjuGyyDRxxFzuv55SiLIXPBRUG6HStU,4233
 linkml/workspaces/example_runner.py,sha256=OmC_yZLIb4KXGQrstBVZL0UAQ9ZAaraguQF0RSf-snk,11611
-linkml-1.7.6.dist-info/entry_points.txt,sha256=7haDkIbyC7ZLhm5z-e3BhrLJpY2xoW1yuD8Y7QPNtVg,2093
-linkml-1.7.6.dist-info/METADATA,sha256=PaI8ylnY-nUYjDrS-44yWh-r6UsiLNLQ_cYYDBNZHX8,3588
-linkml-1.7.6.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.7.6.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.7.6.dist-info/RECORD,,
+linkml-1.7.7.dist-info/entry_points.txt,sha256=7haDkIbyC7ZLhm5z-e3BhrLJpY2xoW1yuD8Y7QPNtVg,2093
+linkml-1.7.7.dist-info/METADATA,sha256=f74yR9Byjm8tw_y28edi2dJtVwthbMwMUocjhXiy0TQ,3656
+linkml-1.7.7.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.7.7.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.7.7.dist-info/RECORD,,