linkml 1.6.5__py3-none-any.whl → 1.6.6__py3-none-any.whl

linkml/generators/owlgen.py

@@ -2,6 +2,7 @@
 import logging
 import os
 from collections import defaultdict
+from copy import copy
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from typing import Any, List, Mapping, Optional, Set, Tuple, Union
@@ -403,6 +404,48 @@ class OwlSchemaGenerator(Generator):
             else:
                 self.graph.add((subject_expr, RDFS.subClassOf, superclass_expr))
 
+    def get_own_slots(self, cls: Union[ClassDefinition, AnonymousClassExpression]) -> List[SlotDefinition]:
+        """
+        Get the slots that are defined on a class, excluding those that are inherited.
+
+        :param cls:
+        :return:
+        """
+        sv = self.schemaview
+        if isinstance(cls, ClassDefinition):
+            own_slots = (
+                list(cls.slot_usage.values()) + list(cls.attributes.values()) + list(cls.slot_conditions.values())
+            )
+            for slot_name in cls.slots:
+                # if slot_name not in cls.slot_usage:
+                slot = sv.get_slot(slot_name)
+                if slot:
+                    own_slots.append(slot)
+                else:
+                    logging.warning(f"Unknown top-level slot {slot_name}")
+        else:
+            own_slots = []
+        own_slots.extend(cls.slot_conditions.values())
+        # merge slots with the same name
+        slot_map = {}
+        for slot in own_slots:
+            if slot.name in slot_map:
+                for k, v in slot.__dict__.items():
+                    curr = slot_map[slot.name].get(k, None)
+                    # print(f"MERGE={slot.name}.{k} = {v} // CURR={curr}")
+                    if v and not curr:
+                        slot_map[slot.name][k] = v
+                        # print(f"OVERRIDE={slot.name}, k={k}, v={v}")
+            else:
+                slot_map[slot.name] = copy(slot.__dict__)
+                # print(f"INIT={slot.name}, vals={slot_map[slot.name]}")
+
+            # print(f"SN={slot.name}, vals={slot_map[slot.name]}")
+        own_slots = [SlotDefinition(**v) for v in slot_map.values()]
+        # sort by name
+        own_slots.sort(key=lambda x: x.name)
+        return own_slots
+
     def transform_class_expression(
         self,
         cls: Union[ClassDefinition, AnonymousClassExpression],
@@ -420,20 +463,7 @@ class OwlSchemaGenerator(Generator):
         """
         graph = self.graph
         sv = self.schemaview
-        if isinstance(cls, ClassDefinition):
-            own_slots = (
-                list(cls.slot_usage.values()) + list(cls.attributes.values()) + list(cls.slot_conditions.values())
-            )
-            for slot_name in cls.slots:
-                if slot_name not in cls.slot_usage:
-                    slot = sv.get_slot(slot_name)
-                    if slot:
-                        own_slots.append(slot)
-        else:
-            own_slots = []
-        own_slots.extend(cls.slot_conditions.values())
-        # sort by name
-        own_slots.sort(key=lambda x: x.name)
+        own_slots = self.get_own_slots(cls)
         owl_exprs = []
         if cls.any_of:
             owl_exprs.append(self._union_of([self.transform_class_expression(x) for x in cls.any_of]))

linkml/generators/projectgen.py

@@ -23,6 +23,7 @@ from linkml.generators.pythongen import PythonGenerator
 from linkml.generators.shaclgen import ShaclGenerator
 from linkml.generators.shexgen import ShExGenerator
 from linkml.generators.sqlddlgen import SQLDDLGenerator
+from linkml.utils.cli_utils import log_level_option
 from linkml.utils.generator import Generator
 
 PATH_FSTRING = str
@@ -103,7 +104,7 @@ class ProjectGenerator:
             all_schemas = [schema_path]
         else:
             all_schemas = get_local_imports(schema_path, os.path.dirname(schema_path))
-        print(f"ALL_SCHEMAS = {all_schemas}")
+        logging.debug(f"ALL_SCHEMAS = {all_schemas}")
         for gen_name, (gen_cls, gen_path_fmt, default_gen_args) in GEN_MAP.items():
             if config.includes is not None and config.includes != [] and gen_name not in config.includes:
                 logging.info(f"Skipping {gen_name} as not in inclusion list: {config.includes}")
@@ -178,6 +179,7 @@ class ProjectGenerator:
     show_default=True,
     help="Merge imports into source file",
 )
+@log_level_option
 @click.argument("yamlfile")
 @click.version_option(__version__, "-V", "--version")
 def cli(
@@ -221,7 +223,6 @@ def cli(
             top_class: Container
 
     """
-    logging.basicConfig(level=logging.INFO)
     project_config = ProjectConfiguration()
     if config_file is not None:
         for k, v in yaml.safe_load(config_file).items():

linkml/generators/pydanticgen.py

@@ -44,14 +44,14 @@ from __future__ import annotations
 from datetime import datetime, date
 from enum import Enum
 from typing import List, Dict, Optional, Any, Union"""
-    if pydantic_ver == 1:
+    if pydantic_ver == "1":
         template += """
-from pydantic import BaseModel as BaseModel, Field"""
-    else:
+from pydantic import BaseModel as BaseModel, Field, validator"""
+    elif pydantic_ver == "2":
         template += """
-from pydantic import BaseModel as BaseModel, ConfigDict, Field"""
-
+from pydantic import BaseModel as BaseModel, ConfigDict,  Field, field_validator"""
     template += """
+import re
 import sys
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -134,7 +134,6 @@ class {{ c.name }}
     {%- endif -%}
     {%- if attr.title != None %}, title="{{attr.title}}"{% endif -%}
     {%- if attr.description %}, description=\"\"\"{{attr.description}}\"\"\"{% endif -%}
-    {%- if attr.pattern %}, regex=\"{{attr.pattern}}\"{% endif -%}
     {%- if attr.equals_number != None %}, le={{attr.equals_number}}, ge={{attr.equals_number}}
     {%- else -%}
      {%- if attr.minimum_value != None %}, ge={{attr.minimum_value}}{% endif -%}
@@ -144,6 +143,21 @@ class {{ c.name }}
     {% else -%}
     None
     {% endfor %}
+    {% for attr in c.attributes.values() if c.attributes -%}
+    {%- if attr.pattern %}
+    @validator('{{attr.name}}', allow_reuse=True)
+    def pattern_{{attr.name}}(cls, v):
+        pattern=re.compile(r"{{attr.pattern}}")
+        if isinstance(v,list):
+            for element in v:
+                if not pattern.match(element):
+                    raise ValueError(f"Invalid {{attr.name}} format: {element}")
+        elif isinstance(v,str):
+            if not pattern.match(v):
+                raise ValueError(f"Invalid {{attr.name}} format: {v}")
+        return v
+    {% endif -%}
+    {% endfor %}    
 {% endfor %}
 """
     elif pydantic_ver == "2":
@@ -172,7 +186,6 @@ class {{ c.name }}
     {%- endif -%}
     {%- if attr.title != None %}, title="{{attr.title}}"{% endif -%}
     {%- if attr.description %}, description=\"\"\"{{attr.description}}\"\"\"{% endif -%}
-    {%- if attr.pattern %}, pattern=\"{{attr.pattern}}\"{% endif -%}
     {%- if attr.equals_number != None %}, le={{attr.equals_number}}, ge={{attr.equals_number}}
     {%- else -%}
      {%- if attr.minimum_value != None %}, ge={{attr.minimum_value}}{% endif -%}
@@ -182,6 +195,21 @@ class {{ c.name }}
     {% else -%}
     None
     {% endfor %}
+    {% for attr in c.attributes.values() if c.attributes -%}
+    {%- if attr.pattern %}
+    @field_validator('{{attr.name}}')
+    def pattern_{{attr.name}}(cls, v):
+        pattern=re.compile(r"{{attr.pattern}}")
+        if isinstance(v,list):
+            for element in v:
+                if not pattern.match(element):
+                    raise ValueError(f"Invalid {{attr.name}} format: {element}")
+        elif isinstance(v,str):
+            if not pattern.match(v):
+                raise ValueError(f"Invalid {{attr.name}} format: {v}")
+        return v
+    {% endif -%}
+    {% endfor %}    
 {% endfor %}
 """
 

linkml/generators/pythongen.py

@@ -802,6 +802,11 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             if self.is_class_unconstrained(self.schema.classes[slot.range]):
                 return ""
 
+        if slot.range in self.schema.enums:
+            # Open enum
+            if not self.schema.enums[slot.range].permissible_values:
+                return ""
+
         aliased_slot_name = self.slot_name(slot.name)  # Mangled name by which the slot is known in python
         _, _, base_type_name = self.class_reference_type(slot, cls)
 

linkml/utils/cli_utils.py

@@ -0,0 +1,25 @@
+import logging
+
+import click
+
+LOG_LEVEL_STRINGS = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
+DEFAULT_LOG_LEVEL: str = "WARNING"
+DEFAULT_LOG_LEVEL_INT: int = logging.WARNING
+
+
+def log_level_option(fn):
+    def callback(ctx, param, value):
+        log_level_string = value.upper()
+        log_level_int = getattr(logging, log_level_string, None)
+        if not isinstance(log_level_int, int):
+            raise ValueError(f"Invalid log level: {log_level_string}")
+        logging.basicConfig(level=log_level_int)
+
+    return click.option(
+        "--log_level",
+        type=click.Choice(LOG_LEVEL_STRINGS),
+        help="Logging level",
+        default=DEFAULT_LOG_LEVEL,
+        show_default=True,
+        callback=callback,
+    )(fn)

linkml/utils/generator.py

@@ -51,13 +51,11 @@ from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.namespaces import Namespaces
 
 from linkml import LOCAL_METAMODEL_YAML_FILE
+from linkml.utils.cli_utils import DEFAULT_LOG_LEVEL_INT, log_level_option
 from linkml.utils.mergeutils import alias_root
 from linkml.utils.schemaloader import SchemaLoader
 from linkml.utils.typereferences import References
 
-DEFAULT_LOG_LEVEL: str = "WARNING"
-DEFAULT_LOG_LEVEL_INT: int = logging.WARNING
-
 
 @lru_cache
 def _resolved_metamodel(mergeimports):
@@ -872,32 +870,16 @@ class Generator(metaclass=abc.ABCMeta):
 
 
 def shared_arguments(g: Type[Generator]) -> Callable[[Command], Command]:
-    _LOG_LEVEL_STRINGS = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
-
-    def _log_level_string_to_int(log_level_string: str) -> int:
-        log_level_string = log_level_string.upper()
-        level = [e for e in log_level_string if e.startswith(log_level_string)]
-        if not level:
-            pass
-        log_level_int = getattr(logging, log_level_string[0], logging.INFO)
-        assert isinstance(log_level_int, int)
-        return log_level_int
-
     def verbosity_callback(ctx, param, verbose):
         if verbose >= 2:
-            logging.basicConfig(level=logging.DEBUG)
+            logging.basicConfig(level=logging.DEBUG, force=True)
         elif verbose == 1:
-            logging.basicConfig(level=logging.INFO)
-        else:
-            logging.basicConfig(level=logging.WARNING)
+            logging.basicConfig(level=logging.INFO, force=True)
 
     def stacktrace_callback(ctx, param, stacktrace):
         if not stacktrace:
             sys.tracebacklimit = 0
 
-    def log_level_callback(ctx, param, value):
-        logging.basicConfig(level=_log_level_string_to_int(value))
-
     def decorator(f: Command) -> Command:
         f.params.append(Argument(("yamlfile",), type=click.Path(exists=True, dir_okay=False)))
         f.params.append(
@@ -926,21 +908,12 @@ def shared_arguments(g: Type[Generator]) -> Callable[[Command], Command]:
             )
         )
         f.params.append(Option(("--importmap", "-im"), type=click.File(), help="Import mapping file"))
-        f.params.append(
-            Option(
-                ("--log_level",),
-                type=click.Choice(_LOG_LEVEL_STRINGS),
-                help="Logging level",
-                default=DEFAULT_LOG_LEVEL,
-                show_default=True,
-                callback=log_level_callback,
-            )
-        )
+        log_level_option(f)
         f.params.append(
             Option(
                 ("--verbose", "-v"),
                 count=True,
-                help="verbosity",
+                help="Verbosity. Takes precedence over --log_level.",
                 callback=verbosity_callback,
             )
         )

linkml/utils/schema_fixer.py

@@ -3,7 +3,7 @@ import re
 from collections import defaultdict
 from copy import copy
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 import click
 import yaml
@@ -319,15 +319,16 @@ class SchemaFixer:
         schema_dict: Dict[str, Any] = None,
         rules: Dict[str, Callable] = None,
         imports=False,
+        preserve_original_using: Optional[str] = None,
     ) -> Union[YAMLRoot, Dict]:
         """
         Changes element names to conform to naming conventions.
 
-
         :param schema: input schema
         :param schema_dict: if specified, the transformation will happen on this dictionary object
         :param rules: mappings between index slots and functions that normalize names
         :param imports: if True, all that imported modules are also fixed
+        :param preserve_original_using: if specified, the original name will be preserved in this slot
         :return:
         """
         if rules is None:
@@ -339,6 +340,7 @@ class SchemaFixer:
             }
         fixes = {}
         sv = SchemaView(schema)
+        preserved = []
         for n, e in sv.all_elements(imports=imports).items():
             if e.from_schema == "https://w3id.org/linkml/types":
                 continue
@@ -348,9 +350,35 @@ class SchemaFixer:
                 normalized = func(n)
                 if normalized != n:
                     fixes[n] = normalized
+                if preserve_original_using is not None:
+                    preserved.append((typ, normalized, n))
+                # if preserve_original_using is not None:
+                #    setattr(e, preserve_original_using, n)
+                #    print(f"SETTING {typ} {e.name}.{preserve_original_using} = {n}")
         if schema_dict is not None:
             schema = schema_dict
-        return yaml_rewrite(schema, fixes)
+        schema = yaml_rewrite(schema, fixes)
+        for typ, normalized, original in preserved:
+            pathmap = {
+                ClassDefinition.__name__: "classes",
+                TypeDefinition.__name__: "types",
+                SlotDefinition.__name__: "slots",
+                EnumDefinition.__name__: "enums",
+            }
+            if isinstance(schema, dict):
+                path = schema[pathmap[typ]]
+                if normalized not in path:
+                    logger.warning(f"Cannot find {typ} {normalized} in {pathmap[typ]}")
+                    continue
+                e = path[normalized]
+                if preserve_original_using not in e:
+                    path[normalized][preserve_original_using] = original
+            else:
+                path = getattr(schema, pathmap[typ])
+                e = path[normalized]
+                if not getattr(e, preserve_original_using, None):
+                    setattr(e, preserve_original_using, original)
+        return schema
 
 
 @click.group()
@@ -376,6 +404,13 @@ def main(verbose: int, quiet: bool):
     show_default=True,
     help="Apply fix to referenced elements from modules",
 )
+@click.option(
+    "--preserve-original-using",
+    "-P",
+    default=None,
+    show_default=True,
+    help="If specified, original name will be preserved in this slot (e.g. title)",
+)
 def fix_names(input_schema, **kwargs):
     """Fix element names to conform to naming conventions"""
     with open(input_schema) as f:

linkml/validator/validator.py

@@ -1,3 +1,4 @@
+from functools import lru_cache
 from pathlib import Path
 from typing import Any, Iterator, List, Optional, TextIO, Union
 
@@ -95,7 +96,7 @@ class Validator:
         if not self._validation_plugins:
             return []
 
-        context = ValidationContext(self._schema, target_class)
+        context = self._context(target_class)
 
         for plugin in self._validation_plugins:
             plugin.pre_process(context)
@@ -117,3 +118,7 @@ class Validator:
 
         for plugin in self._validation_plugins:
             plugin.post_process(context)
+
+    @lru_cache
+    def _context(self, target_class: Optional[str] = None) -> ValidationContext:
+        return ValidationContext(self._schema, target_class)

linkml/workspaces/example_runner.py

@@ -20,8 +20,7 @@ from linkml_runtime.linkml_model import ElementName
 from linkml_runtime.utils.formatutils import camelcase
 
 from linkml.generators.pythongen import PythonGenerator
-from linkml.utils.datavalidator import DataValidator
-from linkml.validators import JsonSchemaDataValidator
+from linkml.validator import Validator, _get_default_validator
 
 
 @dataclass
@@ -77,7 +76,7 @@ class ExampleRunner:
     prefix_map: Optional[Mapping[str, str]] = None
     """Custom prefix map, for emitting RDF/turtle."""
 
-    _validator: Optional[DataValidator] = None
+    _validator: Optional[Validator] = None
 
     expand_dicts: bool = None
     """If true, then expand all dicts prior to validation."""
@@ -101,14 +100,14 @@ class ExampleRunner:
         return self._python_module
 
     @property
-    def validator(self) -> DataValidator:
+    def validator(self) -> Validator:
         """
         Get the current validator
 
         :return:
         """
         if self._validator is None:
-            self._validator = JsonSchemaDataValidator(self.schemaview.schema)
+            self._validator = _get_default_validator(self.schemaview.schema)
         return self._validator
 
     def process_examples(self):
@@ -179,7 +178,11 @@ class ExampleRunner:
                 summary.add(f"## {stem}", "### Input", "```yaml", f"{yaml.dump(input_dict)}", "```")
                 success = True
                 try:
-                    validator.validate_dict(input_dict, tc, closed=True)
+                    report = validator.validate(input_dict, tc)
+                    if report.results:
+                        raise Exception(
+                            "\n".join(f"[{result.severity.value}] {result.message}" for result in report.results)
+                        )
                     # json validation is incomplete: also try object instantiation
                     self._load_from_dict(input_dict, target_class=tc)
                 except Exception as e:

{linkml-1.6.5.dist-info → linkml-1.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.6.5
+Version: 1.6.6
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink

{linkml-1.6.5.dist-info → linkml-1.6.6.dist-info}/RECORD

@@ -34,13 +34,13 @@ linkml/generators/linkmlgen.py,sha256=QhIPA1v2g_g5fien3ZKN-L6TkDk3t7puVFrcoEnwkw
 linkml/generators/markdowngen.py,sha256=ZPLahEPjWsrAsKq4CHbVDXeVd0n1NO-2STs068-g0Ac,32948
 linkml/generators/namespacegen.py,sha256=vVcIyM0zlKd7XRvtdzwTwHjG4Pg49801gy4FUmjJlqQ,6450
 linkml/generators/oocodegen.py,sha256=l-5zck_NNAUxJiApJrnDPkqxCv3b6v5s4hC_smelszU,7620
-linkml/generators/owlgen.py,sha256=6_OJufisaEetp9_bIrnKrQYvhxU8TiJhHZnSIacbEXw,51189
+linkml/generators/owlgen.py,sha256=omOfL5oKHeQs-JARbGbTvydZ6DX4Bzyv5pukgW02kds,52419
 linkml/generators/plantumlgen.py,sha256=Vs__5x9ioiT4IBTbvZUpgT8MsYJ0amfBL64MB_nmQPc,14870
 linkml/generators/prefixmapgen.py,sha256=JJ7hgzuqKVfFZrbDV76Dk8dR2NHsmpp-eNUAspXkfwA,4626
-linkml/generators/projectgen.py,sha256=EVgS5bDzFTm3WAuMg3lC3rzdcaW-hgpq99qZA4nksSY,9544
+linkml/generators/projectgen.py,sha256=g3JR2oXPM_QXhWUGukP9ts1P7tqxIeABaRdv130gbo4,9578
 linkml/generators/protogen.py,sha256=9YfxBZkQdBWwsUbstxEUR4xRWNuAKSfz9zXPhgIYePU,2328
-linkml/generators/pydanticgen.py,sha256=rH__R3Pt7TKQzG2DBo1R5OehQG3FaBMCjXBzZlAWMqw,23742
-linkml/generators/pythongen.py,sha256=7XNlOpScOOpxpo9Q_sasDOZFYaKifbXWQL-OKczpkfY,52327
+linkml/generators/pydanticgen.py,sha256=RoFgX3-_8cx70Q3sUmSrZc0zTHbS0d55HgQp45U7fb4,24872
+linkml/generators/pythongen.py,sha256=yGYlRJ4rNm2QQLFDjyuUnqCyKlzz-b3eSOhkSu8aCwI,52491
 linkml/generators/rdfgen.py,sha256=LxzYBaFEkV7rlf54nWv_6H6AGcWMRXwkaeVXq9VYEc8,2693
 linkml/generators/shaclgen.py,sha256=KxNmDZW2ciCuSqUhJ65TxLTjF8jME1FmN5SaWJCuW9k,8662
 linkml/generators/shexgen.py,sha256=Awtn5SyjS-TUcVCwMdT0F7hNO4K8VcSCYBaFru45Mwg,8994
@@ -82,18 +82,19 @@ linkml/transformers/model_transformer.py,sha256=tK_MpRDI-q2qfe8KHT6qJHP8ZruKjYx1
 linkml/transformers/relmodel_transformer.py,sha256=hRUVtH4gylDssOXoWvVxTetF9ESbITrAZOFu53b_Eg0,17836
 linkml/transformers/schema_renamer.py,sha256=Cr18TyktX64b5iFh5V6R_ILPVzXjbDYVDDZQyqFiAv8,5271
 linkml/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+linkml/utils/cli_utils.py,sha256=MdVbox1qr6kDUHUCWAmFhV-D6ebs_nn8vVwB8KDQfew,742
 linkml/utils/converter.py,sha256=rdhCI7Tsjddr3o1rVBfMq5gQubk_GE6fqlBBmyxI5_M,6270
 linkml/utils/datautils.py,sha256=2XWM9LBSVp8v3SwIZECrX3SjDUYzdnP-syjp6YdL89E,3734
 linkml/utils/datavalidator.py,sha256=kBdWaVi8IZT1bOwEJgJYx-wZAb_PTBObB9nHpYORfKA,472
 linkml/utils/execute_tutorial.py,sha256=T4kHTSyz3ItJGEUZxVjR-3yLVKnOr5Ix4NMGE47-IuE,6912
-linkml/utils/generator.py,sha256=dW9kfVL-7an0ieXR5HLe8bqOyEgDGAoIzdLOu_TFQhc,39101
+linkml/utils/generator.py,sha256=WAlP_gfZfAZYNklsh8l4GtiWZ338kjLg7xpQAANgUNg,38217
 linkml/utils/helpers.py,sha256=yR8n4zFA5wPcYC7xzRuNF3wO16vG80v6j7DM3qTNmIc,447
 linkml/utils/ifabsent_functions.py,sha256=FZwceqwlq81lMPDsdNfSHhtzDXSf8F4cbbhRdnDzjss,5765
 linkml/utils/logictools.py,sha256=GSmBiobC49TcQjE08RtXEE3JwJEOV7eEREio25uJiFs,21184
 linkml/utils/mergeutils.py,sha256=QVm2iQB4v_L2rSvPBsPe9C865R03BgV3TzlPoTTTwWQ,9044
 linkml/utils/rawloader.py,sha256=QB7Rdvy4o4ZJEWBWa2_2xzz2TOh_6Oe4slvUn8IBVIc,4329
 linkml/utils/schema_builder.py,sha256=WLSit3J4lTifaFLLWTwjqIRiTru1pqvTIUuC1TrxS6Y,9902
-linkml/utils/schema_fixer.py,sha256=rjwJB5ukfrgc0Z-j3mKSNzRMkHPp_k_zFKaFNIPeIv8,15086
+linkml/utils/schema_fixer.py,sha256=ajsxpwD4yMjDk1iDtoKJTsa34SIqGshWxlnSNXVZ52w,16745
 linkml/utils/schemaloader.py,sha256=bBSTqimMDTFH2FcKtRz99dKNJzV_myPsZSkIFp_6-A0,46421
 linkml/utils/schemasynopsis.py,sha256=6NKa89bkZfZQE9QM0St-6xQcrsHPkYmBgnnWnlgAcQ4,18455
 linkml/utils/sqlutils.py,sha256=86XeEbfY0Dk-EObw4q5-dxyzSeBtmIhjqqyDcR8ALS0,16591
@@ -114,7 +115,7 @@ linkml/validator/plugins/recommended_slots_plugin.py,sha256=kOdoYQyye47nLA7BjorV
 linkml/validator/plugins/validation_plugin.py,sha256=9SMHF8b2bgG9-8351e8bY676e0A4aEBJSXvMjMF5kXg,1548
 linkml/validator/report.py,sha256=kkkuh-IZF9--cO-2wGjwP3PDLvOcjjvC8AOlxXUIOAM,870
 linkml/validator/validation_context.py,sha256=MmOwLk4cF_Cy7fPdFK61Eti3c3dgzKSIu6r_PmkkoZs,2388
-linkml/validator/validator.py,sha256=jOSdYyC8QIm1GWmllM7Z1_GV-2VO3hwEwdF2AHE-DNY,5476
+linkml/validator/validator.py,sha256=sdWbAOlnNYQWnZSEIuLpGQqH3W4cNq_8M_CdLtsNMH0,5648
 linkml/validators/__init__.py,sha256=43W3J5NPKhwa3ZFHLRYsJMocwQKWGYCF9Ki9r0ccGbc,202
 linkml/validators/jsonschemavalidator.py,sha256=_v0finzU2RGPC5xo0CylYge9XkY7oAigcly2SKLwFuI,7865
 linkml/validators/sparqlvalidator.py,sha256=JowuZ5KxmWkldgWIXAb8DJi7YCPm8x3it0QkgM4lSi0,4612
@@ -122,9 +123,9 @@ linkml/workspaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 linkml/workspaces/datamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml/workspaces/datamodel/workspaces.py,sha256=4HdkqweGNfMPqnB1_Onc9DcTfkhoagTRcqruh08nRoI,14905
 linkml/workspaces/datamodel/workspaces.yaml,sha256=EjVrwPpeRZqJRjuGyyDRxxFzuv55SiLIXPBRUG6HStU,4233
-linkml/workspaces/example_runner.py,sha256=hblnsZVntuwFO4vqcwl_K5XH6jxb52xCtvdc7Sfq_Yc,11452
-linkml-1.6.5.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.6.5.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.6.5.dist-info/METADATA,sha256=dB0BnsijpuHie4nRiNeQ2N5mLQrr0pCu_6msKi2eWZo,3496
-linkml-1.6.5.dist-info/entry_points.txt,sha256=za8r49Z5gcz3rAYTZLbxw5EPZr1rGuxSe1uiRUpf8R0,2143
-linkml-1.6.5.dist-info/RECORD,,
+linkml/workspaces/example_runner.py,sha256=uumXyPZ7xUJSZyRtjDP4TCCxgKSSOfebpufXc0_l0jY,11610
+linkml-1.6.6.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.6.6.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.6.6.dist-info/entry_points.txt,sha256=za8r49Z5gcz3rAYTZLbxw5EPZr1rGuxSe1uiRUpf8R0,2143
+linkml-1.6.6.dist-info/METADATA,sha256=TztvtOceZ4FBx8MPbnRdKJT2xLuWbBb_GOoA7hXLJsY,3496
+linkml-1.6.6.dist-info/RECORD,,