linkml 1.7.6__tar.gz → 1.7.7__tar.gz

{linkml-1.7.6 → linkml-1.7.7}/PKG-INFO

@@ -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 → linkml-1.7.7}/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-1.7.6 → linkml-1.7.7}/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-1.7.6 → linkml-1.7.7}/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-1.7.7/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-1.7.7/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