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

linkml/generators/pythongen.py

@@ -29,6 +29,7 @@ from rdflib import URIRef
 
 import linkml
 from linkml._version import __version__
+from linkml.generators.pydanticgen.template import Import, Imports, ObjectImport
 from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
 
@@ -127,13 +128,120 @@ class PythonGenerator(Generator):
                 self.emit_prefixes.add(type_prefix)
 
     def gen_schema(self) -> str:
+        all_imports = Imports()
+        # generic imports
+        all_imports = (
+            all_imports
+            + Import(module="dataclasses")
+            + Import(module="re")
+            + Import(
+                module="jsonasobj2",
+                objects=[
+                    ObjectImport(name="JsonObj"),
+                    ObjectImport(name="as_dict"),
+                ],
+            )
+            + Import(
+                module="typing",
+                objects=[
+                    ObjectImport(name="Optional"),
+                    ObjectImport(name="List"),
+                    ObjectImport(name="Union"),
+                    ObjectImport(name="Dict"),
+                    ObjectImport(name="ClassVar"),
+                    ObjectImport(name="Any"),
+                ],
+            )
+            + Import(
+                module="dataclasses",
+                objects=[
+                    ObjectImport(name="dataclass"),
+                ],
+            )
+            + Import(
+                module="datetime",
+                objects=[
+                    ObjectImport(name="date"),
+                    ObjectImport(name="datetime"),
+                    ObjectImport(name="time"),
+                ],
+            )
+        )
+
         # The metamodel uses Enumerations to define itself, so don't import if we are generating the metamodel
-        enumimports = (
-            ""
-            if self.genmeta
-            else "from linkml_runtime.linkml_model.meta import EnumDefinition, PermissibleValue, PvFormulaOptions\n"
+        if not self.genmeta:
+            all_imports = all_imports + Import(
+                module="linkml_runtime.linkml_model.meta",
+                objects=[
+                    ObjectImport(name="EnumDefinition"),
+                    ObjectImport(name="PermissibleValue"),
+                    ObjectImport(name="PvFormulaOptions"),
+                ],
+            )
+        # linkml imports
+        all_imports = (
+            all_imports
+            + Import(
+                module="linkml_runtime.utils.slot",
+                objects=[
+                    ObjectImport(name="Slot"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.metamodelcore",
+                objects=[
+                    ObjectImport(name="empty_list"),
+                    ObjectImport(name="empty_dict"),
+                    ObjectImport(name="bnode"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.yamlutils",
+                objects=[
+                    ObjectImport(name="YAMLRoot"),
+                    ObjectImport(name="extended_str"),
+                    ObjectImport(name="extended_float"),
+                    ObjectImport(name="extended_int"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.dataclass_extensions_376",
+                objects=[
+                    ObjectImport(name="dataclasses_init_fn_with_kwargs"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.formatutils",
+                objects=[
+                    ObjectImport(name="camelcase"),
+                    ObjectImport(name="underscore"),
+                    ObjectImport(name="sfx"),
+                ],
+            )
+        )
+
+        # handler import
+        all_imports = all_imports + Import(
+            module="linkml_runtime.utils.enumerations", objects=[ObjectImport(name="EnumDefinitionImpl")]
+        )
+        # other imports
+        all_imports = (
+            all_imports
+            + Import(
+                module="rdflib",
+                objects=[
+                    ObjectImport(name="Namespace"),
+                    ObjectImport(name="URIRef"),
+                ],
+            )
+            + Import(
+                module="linkml_runtime.utils.curienamespace",
+                objects=[
+                    ObjectImport(name="CurieNamespace"),
+                ],
+            )
         )
-        handlerimport = "from linkml_runtime.utils.enumerations import EnumDefinitionImpl"
+
         split_description = ""
         if self.schema.description:
             split_description = "\n#   ".join(d for d in self.schema.description.split("\n") if d is not None)
@@ -151,21 +259,7 @@ class PythonGenerator(Generator):
 # description: {split_description}
 # license: {be(self.schema.license)}
 
-import dataclasses
-import re
-from jsonasobj2 import JsonObj, as_dict
-from typing import Optional, List, Union, Dict, ClassVar, Any
-from dataclasses import dataclass
-from datetime import date, datetime, time
-{enumimports}
-from linkml_runtime.utils.slot import Slot
-from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode
-from linkml_runtime.utils.yamlutils import YAMLRoot, extended_str, extended_float, extended_int
-from linkml_runtime.utils.dataclass_extensions_376 import dataclasses_init_fn_with_kwargs
-from linkml_runtime.utils.formatutils import camelcase, underscore, sfx
-{handlerimport}
-from rdflib import Namespace, URIRef
-from linkml_runtime.utils.curienamespace import CurieNamespace
+{all_imports.render()}
 {self.gen_imports()}
 
 metamodel_version = "{self.schema.metamodel_version}"
@@ -836,7 +930,15 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             ):
                 rlines.append(f"\tself.{aliased_slot_name} = {base_type_name}()")
             else:
-                if (
+                if slot.range in self.schema.enums and slot.ifabsent:
+                    # `ifabsent` for an enumeration cannot be assigned to
+                    # the dataclass field default, because it would be a
+                    # mutable. `python_ifabsent_processor.py` can specify
+                    # the default as string and here that string gets
+                    # converted into an object attribute invocation
+                    # TODO: fix according https://github.com/linkml/linkml/pull/2329#discussion_r1797534588
+                    rlines.append(f"\tself.{aliased_slot_name} = getattr({slot.range}, self.{aliased_slot_name})")
+                elif (
                     (self.class_identifier(slot.range) and not slot.inlined)
                     or slot.range in self.schema.types
                     or slot.range in self.schema.enums

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.4.dist-info → linkml-1.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.4
+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