linkml 1.8.5__py3-none-any.whl → 1.8.6__py3-none-any.whl

linkml/generators/pydanticgen/array.py

@@ -1,7 +1,15 @@
 import sys
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterable, List, Optional, Type, TypeVar, Union, get_args
+from typing import (
+    ClassVar,
+    Iterable,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from linkml_runtime.linkml_model import Element
 from linkml_runtime.linkml_model.meta import ArrayExpression, DimensionExpression
@@ -9,20 +17,15 @@ from pydantic import VERSION as PYDANTIC_VERSION
 
 from linkml.utils.deprecation import deprecation_warning
 
-if int(PYDANTIC_VERSION[0]) >= 2:
-    from pydantic_core import core_schema
-else:
+if int(PYDANTIC_VERSION[0]) < 2:
     # 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
-
-if sys.version_info.minor <= 8:
-    from typing_extensions import Annotated
+if sys.version_info.minor < 12:
+    from typing_extensions import TypeAliasType
 else:
-    from typing import Annotated
+    from typing import TypeAliasType
+
 
 from linkml.generators.pydanticgen.build import RangeResult
 from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
@@ -37,75 +40,32 @@ class ArrayRepresentation(Enum):
 _BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions", "maximum_number_dimensions")
 
 _T = TypeVar("_T")
-_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]
-
-
-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])[:-1]
-
-        if len(item_type) == 1:
-            item_schema = handler.generate_schema(item_type[0])
-        else:
-            item_schema = core_schema.union_schema([handler.generate_schema(i) for i in item_type])
-
-        if all([getattr(i, "__module__", "") == "builtins" and i is not Any for i in item_type]):
-            item_schema["strict"] = True
-
-        # Before python 3.11, `Any` type was a special object without a __name__
-        item_name = "_".join(["Any" if i is Any else i.__name__ for i in item_type])
-
-        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]
+AnyShapeArray = TypeAliasType("AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,))
 
 _AnyShapeArrayImports = (
     Imports()
     + Import(
         module="typing",
         objects=[
-            ObjectImport(name="Generic"),
             ObjectImport(name="Iterable"),
             ObjectImport(name="TypeVar"),
             ObjectImport(name="Union"),
-            ObjectImport(name="get_args"),
         ],
     )
     + ConditionalImport(
-        condition="sys.version_info.minor > 8",
+        condition="sys.version_info.minor >= 12",
         module="typing",
-        objects=[ObjectImport(name="Annotated")],
-        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
+        objects=[ObjectImport(name="TypeAliasType")],
+        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="TypeAliasType")]),
     )
-    + 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]",
+    """AnyShapeArray = TypeAliasType(
+    "AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,)
+)""",
 ]
 
 _ConListImports = Imports() + Import(module="pydantic", objects=[ObjectImport(name="conlist")])

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

@@ -1,4 +1,4 @@
-{{name}}: {{ range }} = Field({{ field }}
+{{name}}: {{ range }} = Field(default={{ field }}
 {%- if title != None %}, title="{{title}}"{% endif -%}
 {%- if description %}, description="""{{description}}"""{% endif -%}
 {%- if equals_number != None %}

linkml/generators/shaclgen.py

@@ -116,10 +116,20 @@ class ShaclGenerator(Generator):
                 order += 1
                 prop_pv_literal(SH.name, s.title)
                 prop_pv_literal(SH.description, s.description)
-                if not s.multivalued:
-                    prop_pv_literal(SH.maxCount, 1)
-                if s.required:
+                # minCount
+                if s.minimum_cardinality:
+                    prop_pv_literal(SH.minCount, s.minimum_cardinality)
+                elif s.exact_cardinality:
+                    prop_pv_literal(SH.minCount, s.exact_cardinality)
+                elif s.required:
                     prop_pv_literal(SH.minCount, 1)
+                # maxCount
+                if s.maximum_cardinality:
+                    prop_pv_literal(SH.maxCount, s.maximum_cardinality)
+                elif s.exact_cardinality:
+                    prop_pv_literal(SH.maxCount, s.exact_cardinality)
+                elif not s.multivalued:
+                    prop_pv_literal(SH.maxCount, 1)
                 prop_pv_literal(SH.minInclusive, s.minimum_value)
                 prop_pv_literal(SH.maxInclusive, s.maximum_value)
 
@@ -198,8 +208,6 @@ class ShaclGenerator(Generator):
                         add_simple_data_type(prop_pv, r)
                     if s.pattern:
                         prop_pv(SH.pattern, Literal(s.pattern))
-                    if s.annotations and self.include_annotations:
-                        self._add_annotations(prop_pv, s)
                     if s.equals_string:
                         # Map equal_string and equal_string_in to sh:in
                         self._and_equals_string(g, prop_pv, [s.equals_string])
@@ -207,6 +215,9 @@ class ShaclGenerator(Generator):
                         # Map equal_string and equal_string_in to sh:in
                         self._and_equals_string(g, prop_pv, s.equals_string_in)
 
+                if s.annotations and self.include_annotations:
+                    self._add_annotations(prop_pv, s)
+
                 default_value = ifabsent_processor.process_slot(s, c)
                 if default_value:
                     prop_pv(SH.defaultValue, default_value)

linkml/generators/typescriptgen.py

@@ -280,7 +280,9 @@ def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, output=None
     gen = TypescriptGenerator(
         yamlfile, gen_type_utils=gen_type_utils, include_induced_slots=include_induced_slots, **args
     )
-    gen.serialize(output=output)
+    serialized = gen.serialize(output=output)
+    if output is None:
+        print(serialized)
 
 
 if __name__ == "__main__":

linkml/linter/rules.py

@@ -134,7 +134,9 @@ class TreeRootClassRule(LinterRule):
             if self.config.validate_existing_class_name:
                 for tree_root in tree_roots:
                     if str(tree_root.name) != self.config.root_class_name:
-                        yield LinterProblem(message=f"Tree root class has name '{tree_root.name}'")
+                        yield LinterProblem(message=f"Tree root class has an invalid name '{tree_root.name}'")
+            if len(tree_roots) > 1:
+                yield LinterProblem("Schema has more than one class with `tree_root: true`")
         else:
             if fix:
                 container = ClassDefinition(self.config.root_class_name, tree_root=True)

linkml/utils/converter.py

@@ -1,8 +1,10 @@
 import logging
 import os
+import pathlib
 import sys
 
 import click
+import yaml
 from linkml_runtime.linkml_model import Prefix
 from linkml_runtime.utils import inference_utils
 from linkml_runtime.utils.compile_python import compile_python
@@ -55,6 +57,7 @@ logger = logging.getLogger(__name__)
 @click.option("--index-slot", "-S", help="top level slot. Required for CSV dumping/loading")
 @click.option("--schema", "-s", help="Path to schema specified as LinkML yaml")
 @click.option("--prefix", "-P", multiple=True, help="Prefixmap base=URI pairs")
+@click.option("--prefix-file", help="Path to yaml file containing base=URI pairs")
 @click.option(
     "--validate/--no-validate",
     default=True,
@@ -79,6 +82,7 @@ def cli(
     input_format=None,
     output_format=None,
     prefix=None,
+    prefix_file=None,
     target_class_from_path=None,
     schema=None,
     validate=None,
@@ -99,6 +103,8 @@ def cli(
 
     For more information, see https://linkml.io/linkml/data/index.html
     """
+    if prefix and prefix_file is not None:
+        raise Exception("Either set prefix OR prefix_file, not both.")
     if prefix is None:
         prefix = []
     if module is None:
@@ -113,6 +119,17 @@ def cli(
         for p in prefix:
             base, uri = p.split("=")
             prefix_map[base] = uri
+    if prefix_file is not None:
+        prefix_path = pathlib.Path(prefix_file).resolve()
+        if not prefix_path.exists():
+            raise Exception(f"Path {prefix_file} to prefix map does not exists.")
+        with open(prefix_path, "r") as prefix_stream:
+            raw_prefix_map = yaml.safe_load(prefix_stream)
+        prefix_file_map = raw_prefix_map.get("prefixes", None)
+        if prefix_file_map is None:
+            raise Exception("Provided prefix file does not contain the prefixes key.")
+        prefix_map = prefix_file_map
+
     if schema is not None:
         sv = SchemaView(schema)
         if prefix_map:

linkml/utils/deprecation.py

@@ -222,6 +222,16 @@ DEPRECATIONS = (
         recommendation="Update dependent packages to use pydantic>=2",
         issue=1925,
     ),
+    Deprecation(
+        name="validators",
+        deprecated_in=SemVer.from_str("1.8.6"),
+        removed_in=SemVer.from_str("1.9.0"),
+        message=(
+            "linkml.validators and linkml.utils.validation are the older versions "
+            "of linkml.validator and have unmaintained, duplicated functionality"
+        ),
+        recommendation="Update to use linkml.validator",
+    ),
 )  # type: tuple[Deprecation, ...]
 
 EMITTED = set()  # type: set[str]

linkml/utils/helpers.py

@@ -1,4 +1,13 @@
 import re
+from functools import lru_cache
+from typing import List, Tuple, Union
+
+from linkml_runtime import SchemaView
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ElementName,
+    SlotDefinition,
+)
 
 
 def remove_duplicates(lst):
@@ -14,3 +23,59 @@ def write_to_file(file_path, data, mode="w", encoding="utf-8"):
 def convert_to_snake_case(str):
     str = re.sub(r"(?<=[a-z])(?=[A-Z])|[^a-zA-Z]", " ", str).strip().replace(" ", "_")
     return "".join(str.lower())
+
+
+@lru_cache(None)
+def get_range_associated_slots(
+    schemaview: SchemaView, range_class: ClassDefinition
+) -> Tuple[Union[SlotDefinition, None], Union[SlotDefinition, None], Union[List[SlotDefinition], None]]:
+    if isinstance(range_class, ElementName):
+        range_class = schemaview.get_class(range_class)
+    if range_class is None:
+        return None, None, None
+
+    range_class_id_slot = schemaview.get_identifier_slot(range_class.name, use_key=True)
+    if range_class_id_slot is None:
+        return None, None, None
+
+    non_id_slots = [s for s in schemaview.class_induced_slots(range_class.name) if s.name != range_class_id_slot.name]
+    non_id_required_slots = [s for s in non_id_slots if s.required]
+
+    # Some lists of objects can be serialized as SimpleDicts.
+    # A SimpleDict is serialized as simple key-value pairs where the value is atomic.
+    # The key must be declared as a key, and the value must satisfy one of the following conditions:
+    # 1. The value slot is the only other slot in the object other than the key
+    # 2. The value slot is explicitly annotated as a simple_dict_value
+    # 3. The value slot is the only non-key that is required
+    # See also: https://github.com/linkml/linkml/issues/1250
+    range_simple_dict_value_slot = None
+    if len(non_id_slots) == 1:
+        range_simple_dict_value_slot = non_id_slots[0]
+    elif len(non_id_slots) > 1:
+        candidate_non_id_slots = []
+        for non_id_slot in non_id_slots:
+            if isinstance(non_id_slot.annotations, dict):
+                is_simple_dict_value = non_id_slot.annotations.get("simple_dict_value", False)
+            else:
+                is_simple_dict_value = getattr(non_id_slot.annotations, "simple_dict_value", False)
+            if is_simple_dict_value:
+                candidate_non_id_slots.append(non_id_slot)
+        if len(candidate_non_id_slots) == 1:
+            range_simple_dict_value_slot = candidate_non_id_slots[0]
+        else:
+            candidate_non_id_slots = []
+            for non_id_slot in non_id_slots:
+                if non_id_slot.required:
+                    candidate_non_id_slots.append(non_id_slot)
+            if len(candidate_non_id_slots) == 1:
+                range_simple_dict_value_slot = candidate_non_id_slots[0]
+
+    return range_class_id_slot, range_simple_dict_value_slot, non_id_required_slots
+
+
+def is_simple_dict(schemaview: SchemaView, slot: SlotDefinition) -> bool:
+    if not slot.multivalued or not slot.inlined or slot.inlined_as_list:
+        return False
+    else:
+        _, range_simple_dict_value_slot, _ = get_range_associated_slots(schemaview, slot.range)
+        return range_simple_dict_value_slot is not None

linkml/utils/validation.py

@@ -7,6 +7,7 @@ from linkml_runtime.linkml_model import SchemaDefinition
 from linkml_runtime.utils.yamlutils import YAMLRoot
 
 from linkml.generators.jsonschemagen import JsonSchemaGenerator
+from linkml.utils.deprecation import deprecation_warning
 
 
 def _as_dict(inst):
@@ -16,7 +17,6 @@ def _as_dict(inst):
     return inst_dict
 
 
-# Deprecated: use validators module
 def validate_object(
     data: YAMLRoot,
     schema: Union[str, TextIO, SchemaDefinition],
@@ -32,6 +32,7 @@ def validate_object(
     :param closed:
     :return:
     """
+    deprecation_warning("validators")
     if target_class is None:
         target_class = type(data)
     inst_dict = _as_dict(data)

linkml/validator/__init__.py

@@ -60,7 +60,7 @@ def validate(
         otherwise it should be a ``SchemaDefinition`` instance.
     :param target_class: Name of the class within the schema to validate
         against. If ``None``, the class will be inferred from the schema by
-        looked for a class with ``tree_root: true``. Defaults to ``None``.
+        looking for a class with ``tree_root: true``. Defaults to ``None``.
     :param strict: If ``True``, validation will stop after the first validation
         error is found, Otherwise all validation problems will be reported.
         Defaults to ``False``.
@@ -99,7 +99,7 @@ def validate_file(
         otherwise it should be a ``SchemaDefinition`` instance.
     :param target_class: Name of the class within the schema to validate
         against. If ``None``, the class will be inferred from the schema by
-        looked for a class with ``tree_root: true``. Defaults to ``None``.
+        looking for a class with ``tree_root: true``. Defaults to ``None``.
     :param strict: If ``True``, validation will stop after the first validation
         error is found, Otherwise all validation problems will be reported.
         Defaults to ``False``.

linkml/validator/plugins/jsonschema_validation_plugin.py

@@ -55,4 +55,5 @@ class JsonschemaValidationPlugin(ValidationPlugin):
                 instantiates=context.target_class,
                 message=f"{best_error.message} in /{'/'.join(str(p) for p in best_error.absolute_path)}",
                 context=error_context,
+                source=best_error,
             )

linkml/validator/report.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Any, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class Severity(str, Enum):
@@ -30,6 +30,9 @@ class ValidationResult(BaseModel):
     instantiates: Optional[str] = None
     context: List[str] = []
 
+    # The source object that caused this validation result
+    source: Any = Field(None, description="The source of this validation result", exclude=True)
+
 
 class ValidationReport(BaseModel):
     """

linkml/validator/validator.py

@@ -48,7 +48,7 @@ class Validator:
         :param instance: The instance to validate
         :param target_class: Name of the class within the schema to validate
             against. If ``None``, the class will be inferred from the schema by
-            looked for a class with ``tree_root: true``. Defaults to ``None``.
+            looking for a class with ``tree_root: true``. Defaults to ``None``.
         :return: A validation report
         :rtype: ValidationReport
         """
@@ -61,7 +61,7 @@ class Validator:
             which provides the instances to validate
         :param target_class: Name of the class within the schema to validate
             against. If ``None``, the class will be inferred from the schema by
-            looked for a class with ``tree_root: true``. Defaults to ``None``.
+            looking for a class with ``tree_root: true``. Defaults to ``None``.
         :return: A validation report
         :rtype: ValidationReport
         """
@@ -73,7 +73,7 @@ class Validator:
         :param instance: The instance to validate
         :param target_class: Name of the class within the schema to validate
             against. If ``None``, the class will be inferred from the schema by
-            looked for a class with ``tree_root: true``. Defaults to ``None``.
+            looking for a class with ``tree_root: true``. Defaults to ``None``.
         :return: Iterator over validation results
         :rtype: Iterator[ValidationResult]
         """
@@ -89,7 +89,7 @@ class Validator:
             which provides the instances to validate
         :param target_class: Name of the class within the schema to validate
             against. If ``None``, the class will be inferred from the schema by
-            looked for a class with ``tree_root: true``. Defaults to ``None``.
+            looking for a class with ``tree_root: true``. Defaults to ``None``.
         :return: Iterator over validation results
         :rtype: Iterator[ValidationResult]
         """

linkml/validators/jsonschemavalidator.py

@@ -18,6 +18,7 @@ from linkml.generators.jsonschemagen import JsonSchemaGenerator
 from linkml.generators.pythongen import PythonGenerator
 from linkml.utils import datautils
 from linkml.utils.datavalidator import DataValidator
+from linkml.utils.deprecation import deprecation_warning
 
 logger = logging.getLogger(__name__)
 
@@ -29,6 +30,7 @@ class HashableSchemaDefinition(SchemaDefinition):
 
 @lru_cache(maxsize=None)
 def _generate_jsonschema(schema, top_class, closed, include_range_class_descendants):
+    deprecation_warning("validators")
     logger.debug("Generating JSON Schema")
     not_closed = not closed
     return JsonSchemaGenerator(
@@ -42,6 +44,7 @@ def _generate_jsonschema(schema, top_class, closed, include_range_class_descenda
 
 class JsonSchemaDataValidatorError(Exception):
     def __init__(self, validation_messages: List[str]) -> None:
+        deprecation_warning("validators")
         super().__init__("\n".join(validation_messages))
         self.validation_messages = validation_messages
 
@@ -56,6 +59,7 @@ class JsonSchemaDataValidator(DataValidator):
     _hashable_schema: Union[str, HashableSchemaDefinition] = field(init=False, repr=False)
 
     def __setattr__(self, __name: str, __value: Any) -> None:
+        deprecation_warning("validators")
         if __name == "schema":
             if isinstance(__value, SchemaDefinition):
                 self._hashable_schema = HashableSchemaDefinition(**asdict(__value))
@@ -65,6 +69,7 @@ class JsonSchemaDataValidator(DataValidator):
 
     def validate_file(self, input: str, format: str = "json", **kwargs):
         # return self.validate_object(obj)
+        deprecation_warning("validators")
         pass
 
     def validate_object(self, data: YAMLRoot, target_class: Type[YAMLRoot] = None, closed: bool = True) -> None:
@@ -76,6 +81,7 @@ class JsonSchemaDataValidator(DataValidator):
         :param closed:
         :return:
         """
+        deprecation_warning("validators")
         if target_class is None:
             target_class = type(data)
         inst_dict = as_simple_dict(data)
@@ -90,6 +96,7 @@ class JsonSchemaDataValidator(DataValidator):
         :param closed:
         :return:
         """
+        deprecation_warning("validators")
         results = list(self.iter_validate_dict(data, target_class, closed))
         if results:
             raise JsonSchemaDataValidatorError(results)
@@ -97,6 +104,7 @@ class JsonSchemaDataValidator(DataValidator):
     def iter_validate_dict(
         self, data: dict, target_class_name: ClassDefinitionName = None, closed: bool = True
     ) -> Iterable[str]:
+        deprecation_warning("validators")
         if self.schema is None:
             raise ValueError("schema object must be set")
         if target_class_name is None:
@@ -159,6 +167,8 @@ def cli(
     """
     Validates instance data
     """
+    deprecation_warning("validators")
+
     if module is None:
         if schema is None:
             raise Exception("must pass one of module OR schema")

linkml/validators/sparqlvalidator.py

@@ -14,11 +14,13 @@ from linkml.generators.sparqlgen import SparqlGenerator
 from linkml.reporting import CheckResult, Report
 from linkml.utils.datautils import _get_format, dumpers_loaders, get_dumper
 from linkml.utils.datavalidator import DataValidator
+from linkml.utils.deprecation import deprecation_warning
 
 logger = logging.getLogger(__name__)
 
 
 def sparqljson2dict(row: dict):
+    deprecation_warning("validators")
     return {k: v["value"] for k, v in row.items()}
 
 
@@ -37,11 +39,13 @@ class SparqlDataValidator(DataValidator):
     queries: dict = None
 
     def validate_file(self, input: str, format: str = "turtle", **kwargs):
+        deprecation_warning("validators")
         g = Graph()
         g.parse(input, format=format)
         return self.validate_graph(g, **kwargs)
 
     def validate_graph(self, g: Graph, **kwargs):
+        deprecation_warning("validators")
         if self.queries is None:
             self.queries = SparqlGenerator(self.schema, **kwargs).queries
         invalid = []
@@ -61,6 +65,7 @@ class SparqlDataValidator(DataValidator):
         return invalid
 
     def validate_endpoint(self, url: str, **kwargs):
+        deprecation_warning("validators")
         if self.queries is None:
             self.queries = SparqlGenerator(self.schema, **kwargs).queries
         invalid = []
@@ -81,6 +86,7 @@ class SparqlDataValidator(DataValidator):
         return report
 
     def load_schema(self, schema: Union[str, SchemaDefinition]):
+        deprecation_warning("validators")
         self.schemaview = SchemaView(schema)
         self.schema = self.schemaview.schema
         # self.schema = YAMLGenerator(schema).schema
@@ -124,6 +130,7 @@ def cli(
 
         linkml-sparql-validate -U http://sparql.hegroup.org/sparql -s tests/test_validation/input/omo.yaml
     """
+    deprecation_warning("validators")
     validator = SparqlDataValidator(schema)
     if endpoint_url is not None:
         results = validator.validate_endpoint(endpoint_url, limit=limit, named_graphs=named_graph)

linkml/workspaces/example_runner.py

@@ -22,6 +22,7 @@ from linkml_runtime.utils.formatutils import camelcase
 
 from linkml._version import __version__
 from linkml.generators.pythongen import PythonGenerator
+from linkml.utils.helpers import get_range_associated_slots
 from linkml.validator import Validator, _get_default_validator
 
 logger = logging.getLogger(__name__)
@@ -244,10 +245,28 @@ class ExampleRunner:
                     raise ValueError(f"Cannot find unique class for URI {target_class}; got: {target_classes}")
                 target_class = target_classes[0]
             new_dict_obj = {}
+
             for k, v in dict_obj.items():
                 if v is not None:
                     islot = sv.induced_slot(k, target_class)
-                    v2 = self._load_from_dict(v, target_class=islot.range)
+                    # if slot is a dictionary, repeat key in dictionary value object
+                    if islot.multivalued and islot.inlined and not islot.inlined_as_list:
+                        (range_id_slot, range_simple_dict_value_slot, _) = get_range_associated_slots(
+                            self.schemaview, islot.range
+                        )
+                        v_as_list = []
+                        for ik, iv in v.items():
+                            # simple dictionaries can be simply created
+                            if range_simple_dict_value_slot is not None:
+                                value = {range_id_slot.name: ik, range_simple_dict_value_slot.name: iv}
+                            # other dictionaries => simply add the identifier to the dictionary
+                            else:
+                                value = iv
+                                value[range_id_slot.name] = ik
+                            v_as_list.append(value)
+                        v2 = self._load_from_dict(v_as_list, target_class=islot.range)
+                    else:
+                        v2 = self._load_from_dict(v, target_class=islot.range)
                     new_dict_obj[k] = v2
             py_target_class = getattr(self.python_module, camelcase(target_class))
             return py_target_class(**new_dict_obj)

{linkml-1.8.5.dist-info → linkml-1.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.5
+Version: 1.8.6
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -53,7 +53,7 @@ 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.4.0) ; python_version < "3.9"
+Requires-Dist: typing-extensions (>=4.6.0) ; python_version < "3.12"
 Requires-Dist: watchdog (>=0.9.0)
 Project-URL: Documentation, https://linkml.io/linkml/
 Project-URL: Repository, https://github.com/linkml/linkml