linkml 1.7.10__py3-none-any.whl → 1.8.0__py3-none-any.whl

linkml/generators/docgen/class.md.jinja2

@@ -99,20 +99,6 @@ URI: {{ gen.uri_link(element) }}
 
 {% include "common_metadata.md.jinja2" %}
 
-
-{% if schemaview.get_mappings(element.name).items() -%}
-## Mappings
-
-| Mapping Type | Mapped Value |
-| ---  | ---  |
-{% for m, mt in schemaview.get_mappings(element.name).items() -%}
-{% if mt|length > 0 -%}
-| {{ m }} | {{ mt|join(', ') }} |
-{% endif -%}
-{% endfor %}
-
-{% endif -%}
-
 {% if gen.example_object_blobs(element.name) -%}
 ## Examples
 {% for name, blob in gen.example_object_blobs(element.name) -%}

linkml/generators/docgen/common_metadata.md.jinja2

@@ -75,4 +75,17 @@ Instances of this class *should* have identifiers with one of the following pref
 {% if element.imported_from %}
 * imported from: {{ element.imported_from }}
 {% endif %}
-{% endif %}
+{% endif %}
+
+{% if schemaview.get_mappings(element.name).items() -%}
+## Mappings
+
+| Mapping Type | Mapped Value |
+| ---  | ---  |
+{% for m, mt in schemaview.get_mappings(element.name).items() -%}
+{% if mt|length > 0 -%}
+| {{ m }} | {{ mt|join(', ') }} |
+{% endif -%}
+{% endfor %}
+
+{% endif -%}

linkml/generators/erdiagramgen.py

@@ -1,7 +1,7 @@
 import os
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, Optional, Union
+from typing import List, Optional, Set, Union
 
 import click
 import pydantic
@@ -163,6 +163,7 @@ class ERDiagramGenerator(Generator):
         class_names: List[Union[str, ClassDefinitionName]],
         follow_references=False,
         max_hops: int = None,
+        include_upstream: bool = False,
     ) -> MERMAID_SERIALIZATION:
         """
         Serialize a list of classes as an ER Diagram.
@@ -195,6 +196,15 @@ class ERDiagramGenerator(Generator):
                     if follow_references or sv.is_inlined(slot):
                         if rng not in visited:
                             stack.append((rng, depth + 1))
+
+        # Now Add upstream classes if needed
+        if include_upstream:
+            for sn in sv.all_slots():
+                slot = sv.schema.slots.get(sn)
+                if slot and slot.range in set(class_names):
+                    for cl in sv.all_classes():
+                        if slot.name in sv.get_class(cl).slots and cl not in visited:
+                            self.add_upstream_class(cl, set(class_names), diagram)
         return self.serialize_diagram(diagram)
 
     def serialize_diagram(self, diagram: ERDiagram) -> str:
@@ -210,6 +220,15 @@ class ERDiagramGenerator(Generator):
         else:
             return er
 
+    def add_upstream_class(self, class_name: ClassDefinitionName, targets: Set[str], diagram: ERDiagram) -> None:
+        sv = self.schemaview
+        cls = sv.get_class(class_name)
+        entity = Entity(name=camelcase(cls.name))
+        diagram.entities.append(entity)
+        for slot in sv.class_induced_slots(class_name):
+            if slot.range in targets:
+                self.add_relationship(entity, slot, diagram)
+
     def add_class(self, class_name: ClassDefinitionName, diagram: ERDiagram) -> None:
         """
         Add a class to the ER Diagram.
@@ -291,9 +310,17 @@ class ERDiagramGenerator(Generator):
 )
 @click.option("--max-hops", default=None, type=click.INT, help="Maximum number of hops")
 @click.option("--classes", "-c", multiple=True, help="List of classes to serialize")
+@click.option("--include-upstream", is_flag=True, help="Include upstream classes")
 @click.version_option(__version__, "-V", "--version")
 @click.command()
-def cli(yamlfile, classes: List[str], max_hops: Optional[int], follow_references: bool, **args):
+def cli(
+    yamlfile,
+    classes: List[str],
+    max_hops: Optional[int],
+    follow_references: bool,
+    include_upstream: bool = False,
+    **args,
+):
     """Generate a mermaid ER diagram from a schema.
 
     By default, all entities traversable from the tree_root are included. If no tree_root is
@@ -306,7 +333,14 @@ def cli(yamlfile, classes: List[str], max_hops: Optional[int], follow_references
         **args,
     )
     if classes:
-        print(gen.serialize_classes(classes, follow_references=follow_references, max_hops=max_hops))
+        print(
+            gen.serialize_classes(
+                classes,
+                follow_references=follow_references,
+                max_hops=max_hops,
+                include_upstream=include_upstream,
+            )
+        )
     else:
         print(gen.serialize())
 

linkml/generators/golanggen.py

@@ -5,12 +5,7 @@ from typing import List, Optional
 
 import click
 from jinja2 import Template
-from linkml_runtime.linkml_model.meta import (
-    ClassDefinition,
-    ClassDefinitionName,
-    Element,
-    SlotDefinition,
-)
+from linkml_runtime.linkml_model.meta import ClassDefinition, ClassDefinitionName, Element, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, underscore
 
 from linkml._version import __version__

linkml/generators/plantumlgen.py

@@ -12,11 +12,7 @@ from typing import Callable, List, Optional, Set, cast
 
 import click
 import requests
-from linkml_runtime.linkml_model.meta import (
-    ClassDefinition,
-    ClassDefinitionName,
-    SlotDefinition,
-)
+from linkml_runtime.linkml_model.meta import ClassDefinition, ClassDefinitionName, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, underscore
 
 from linkml import REQUESTS_TIMEOUT

linkml/generators/pydanticgen/array.py

@@ -1,18 +1,7 @@
 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 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

linkml/generators/pydanticgen/black.py

@@ -16,9 +16,7 @@ except ImportError:
 
 
 def _default_mode() -> "Mode":
-    return Mode(
-        target_versions={TargetVersion.PY311},
-    )
+    return Mode(target_versions={TargetVersion.PY311}, line_length=120)
 
 
 def format_black(code: str, mode: Optional["Mode"] = None) -> str:

linkml/generators/pydanticgen/includes.py

@@ -0,0 +1,46 @@
+"""
+Classes to inject in generated pydantic models
+"""
+
+from pydantic.version import VERSION
+
+PYDANTIC_VERSION = int(VERSION[0])
+
+
+LinkMLMeta_v1 = """
+class LinkMLMeta(BaseModel):
+    __root__: Dict[str, Any] = {}
+    
+    def __getattr__(self, key:str):
+        return getattr(self.__root__, key)
+        
+    def __getitem__(self, key:str):
+        return self.__root__[key]
+    
+    def __setitem__(self, key:str, value):
+        self.__root__[key] = value
+   
+    class Config:
+        allow_mutation = False
+"""
+
+LinkMLMeta_v2 = """
+class LinkMLMeta(RootModel):
+    root: Dict[str, Any] = {}
+    model_config = ConfigDict(frozen=True)
+    
+    def __getattr__(self, key:str):
+        return getattr(self.root, key)
+        
+    def __getitem__(self, key:str):
+        return self.root[key]
+    
+    def __setitem__(self, key:str, value):
+        self.root[key] = value
+    
+"""
+
+# if PYDANTIC_VERSION >= 2:
+#     LinkMLMeta = eval(LinkMLMeta_v2)
+# else:
+#     LinkMLMeta = eval(LinkMLMeta_v1)

linkml/generators/pydanticgen/pydanticgen.py

@@ -3,19 +3,12 @@ import logging
 import os
 import textwrap
 from collections import defaultdict
-from copy import deepcopy
+from copy import copy, deepcopy
 from dataclasses import dataclass, field
+from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import (
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Set,
-    Type,
-    Union,
-)
+from typing import Dict, List, Literal, Optional, Set, Type, TypeVar, Union, overload
 
 import click
 from jinja2 import ChoiceLoader, Environment, FileSystemLoader
@@ -27,16 +20,14 @@ from linkml_runtime.linkml_model.meta import (
     TypeDefinition,
 )
 from linkml_runtime.utils.compile_python import compile_python
-from linkml_runtime.utils.formatutils import camelcase, underscore
+from linkml_runtime.utils.formatutils import camelcase, remove_empty_items, underscore
 from linkml_runtime.utils.schemaview import SchemaView
 from pydantic.version import VERSION as PYDANTIC_VERSION
 
 from linkml._version import __version__
-from linkml.generators.common.type_designators import (
-    get_accepted_type_designator_values,
-    get_type_designator_value,
-)
+from linkml.generators.common.type_designators import get_accepted_type_designator_values, get_type_designator_value
 from linkml.generators.oocodegen import OOCodeGenerator
+from linkml.generators.pydanticgen import includes
 from linkml.generators.pydanticgen.array import ArrayRangeGenerator, ArrayRepresentation
 from linkml.generators.pydanticgen.build import SlotResult
 from linkml.generators.pydanticgen.template import (
@@ -85,6 +76,7 @@ DEFAULT_IMPORTS = (
         module="typing",
         objects=[
             ObjectImport(name="Any"),
+            ObjectImport(name="ClassVar"),
             ObjectImport(name="List"),
             ObjectImport(name="Literal"),
             ObjectImport(name="Dict"),
@@ -100,6 +92,7 @@ DEFAULT_IMPORTS = (
             ObjectImport(name="BaseModel"),
             ObjectImport(name="ConfigDict"),
             ObjectImport(name="Field"),
+            ObjectImport(name="RootModel"),
             ObjectImport(name="field_validator"),
         ],
         alternative=Import(
@@ -109,6 +102,33 @@ DEFAULT_IMPORTS = (
     )
 )
 
+DEFAULT_INJECTS = {1: [includes.LinkMLMeta_v1], 2: [includes.LinkMLMeta_v2]}
+
+
+class MetadataMode(str, Enum):
+    FULL = "full"
+    """
+    all metadata from the source schema will be included, even if it is represented by the template classes, 
+    and even if it is represented by some child class (eg. "classes" will be included with schema metadata
+    """
+    EXCEPT_CHILDREN = "except_children"
+    """
+    all metadata from the source schema will be included, even if it is represented by the template classes,
+    except if it is represented by some child template class (eg. "classes" will be excluded from schema metadata)
+    """
+    AUTO = "auto"
+    """
+    Only the metadata that isn't represented by the template classes or excluded with ``meta_exclude`` will be included 
+    """
+    NONE = None
+    """
+    No metadata will be included.
+    """
+
+
+DefinitionType = TypeVar("DefinitionType", bound=Union[SchemaDefinition, ClassDefinition, SlotDefinition])
+TemplateType = TypeVar("TemplateType", bound=Union[PydanticModule, PydanticClass, PydanticAttribute])
+
 
 @dataclass
 class PydanticGenerator(OOCodeGenerator):
@@ -212,6 +232,12 @@ class PydanticGenerator(OOCodeGenerator):
             from typing_extensions import Literal
         
     """
+    metadata_mode: Union[MetadataMode, str, None] = MetadataMode.AUTO
+    """
+    How to include schema metadata in generated pydantic models.
+    
+    See :class:`.MetadataMode` for mode documentation
+    """
 
     # ObjectVars (identical to pythongen)
     gen_classvars: bool = True
@@ -530,6 +556,56 @@ class PydanticGenerator(OOCodeGenerator):
 
         return array_reps
 
+    @overload
+    def include_metadata(self, model: PydanticModule, source: SchemaDefinition) -> PydanticModule: ...
+
+    @overload
+    def include_metadata(self, model: PydanticClass, source: ClassDefinition) -> PydanticClass: ...
+
+    @overload
+    def include_metadata(self, model: PydanticAttribute, source: SlotDefinition) -> PydanticAttribute: ...
+
+    def include_metadata(self, model: TemplateType, source: DefinitionType) -> TemplateType:
+        """
+        Include metadata from the source schema that is otherwise not represented in the pydantic template models.
+
+        Metadata inclusion mode is dependent on :attr:`.metadata_mode` - see:
+
+        - :class:`.MetadataMode`
+        - :meth:`.TemplateModel.exclude_from_meta`
+
+        """
+        if self.metadata_mode is None or self.metadata_mode == MetadataMode.NONE:
+            return model
+        elif self.metadata_mode in (MetadataMode.AUTO, MetadataMode.AUTO.value):
+            meta = {k: v for k, v in remove_empty_items(source).items() if k not in model.exclude_from_meta()}
+        elif self.metadata_mode in (MetadataMode.EXCEPT_CHILDREN, MetadataMode.EXCEPT_CHILDREN.value):
+            meta = {}
+            for k, v in remove_empty_items(source).items():
+                if not hasattr(model, k):
+                    meta[k] = v
+                elif isinstance(getattr(model, k), list) and not any(
+                    [isinstance(item, TemplateModel) for item in getattr(model, k)]
+                ):
+                    meta[k] = v
+                elif isinstance(getattr(model, k), dict) and not any(
+                    [isinstance(item, TemplateModel) for item in getattr(model, k).values()]
+                ):
+                    meta[k] = v
+                elif not isinstance(getattr(model, k), TemplateModel):
+                    meta[k] = v
+
+        elif self.metadata_mode in (MetadataMode.FULL, MetadataMode.FULL.value):
+            meta = remove_empty_items(source)
+        else:
+            raise ValueError(
+                f"Unknown metadata mode '{self.metadata_mode}', needs to be one of "
+                f"{[mode.value for mode in MetadataMode]}"
+            )
+
+        model.meta = meta
+        return model
+
     def render(self) -> PydanticModule:
         sv: SchemaView
         sv = self.schemaview
@@ -540,7 +616,7 @@ class PydanticGenerator(OOCodeGenerator):
             description=schema.description.replace('"', '\\"') if schema.description else None,
         )
         enums = self.generate_enums(sv.all_enums())
-        injected_classes = []
+        injected_classes = copy(DEFAULT_INJECTS[self.pydantic_version])
         if self.injected_classes is not None:
             injected_classes += self.injected_classes
 
@@ -665,15 +741,22 @@ class PydanticGenerator(OOCodeGenerator):
                     predef_slot = str(predef_slot)
                 new_fields["predefined"] = predef_slot
                 new_fields["name"] = attr_name
+
                 attrs[attr_name] = PydanticAttribute(**new_fields, pydantic_ver=self.pydantic_version)
+                attrs[attr_name] = self.include_metadata(attrs[attr_name], src_attr)
 
             new_class = PydanticClass(
                 name=k, attributes=attrs, description=c.description, pydantic_ver=self.pydantic_version
             )
+            new_class = self.include_metadata(new_class, c)
             if k in bases:
                 new_class.bases = bases[k]
             classes[k] = new_class
 
+        schema_meta = {
+            k: v for k, v in remove_empty_items(schema).items() if k not in PydanticModule.exclude_from_meta()
+        }
+
         module = PydanticModule(
             pydantic_ver=self.pydantic_version,
             metamodel_version=self.schema.metamodel_version,
@@ -683,7 +766,9 @@ class PydanticGenerator(OOCodeGenerator):
             injected_classes=injected_classes,
             enums=enums,
             classes=classes,
+            meta=schema_meta,
         )
+        module = self.include_metadata(module, pyschema)
         return module
 
     def serialize(self) -> str:
@@ -739,6 +824,12 @@ Available templates to override:
     default="forbid",
     help="How to handle extra fields in BaseModel.",
 )
+@click.option(
+    "--black",
+    is_flag=True,
+    default=False,
+    help="Format generated models with black (must be present in the environment)",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command()
 def cli(
@@ -752,6 +843,7 @@ def cli(
     array_representations=list("list"),
     pydantic_version=int(PYDANTIC_VERSION[0]),
     extra_fields: Literal["allow", "forbid", "ignore"] = "forbid",
+    black: bool = False,
     **args,
 ):
     """Generate pydantic classes to represent a LinkML model"""
@@ -777,6 +869,7 @@ def cli(
         gen_classvars=classvars,
         gen_slots=slots,
         template_dir=template_dir,
+        black=black,
         **args,
     )
     print(gen.serialize())

linkml/generators/pydanticgen/template.py

@@ -60,6 +60,7 @@ class TemplateModel(BaseModel):
     )
 
     pydantic_ver: int = int(PYDANTIC_VERSION[0])
+    meta_exclude: ClassVar[List[str]] = None
 
     def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
         """
@@ -132,6 +133,16 @@ class TemplateModel(BaseModel):
                 return self.json(**kwargs)
             return self.dict(**kwargs)
 
+    @classmethod
+    def exclude_from_meta(cls: "TemplateModel") -> List[str]:
+        """
+        Attributes in the source definition to exclude from linkml_meta
+        """
+        ret = [*cls.model_fields.keys()]
+        if cls.meta_exclude is not None:
+            ret = ret + cls.meta_exclude
+        return ret
+
 
 def _render(
     item: Union[TemplateModel, Any, List[Union[Any, TemplateModel]], Dict[str, Union[Any, TemplateModel]]],
@@ -213,6 +224,7 @@ class PydanticAttribute(TemplateModel):
     """
 
     template: ClassVar[str] = "attribute.py.jinja"
+    meta_exclude: ClassVar[List[str]] = ["from_schema", "owner", "range", "multivalued", "inlined", "inlined_as_list"]
 
     name: str
     required: bool = False
@@ -237,6 +249,10 @@ class PydanticAttribute(TemplateModel):
     minimum_value: Optional[Union[int, float]] = None
     maximum_value: Optional[Union[int, float]] = None
     pattern: Optional[str] = None
+    meta: Optional[Dict[str, Any]] = None
+    """
+    Metadata for the slot to be included in a Field annotation
+    """
 
     if int(PYDANTIC_VERSION[0]) >= 2:
 
@@ -283,11 +299,16 @@ class PydanticClass(TemplateModel):
     """
 
     template: ClassVar[str] = "class.py.jinja"
+    meta_exclude: ClassVar[List[str]] = ["slots", "is_a"]
 
     name: str
     bases: Union[List[str], str] = PydanticBaseModel.default_name
     description: Optional[str] = None
     attributes: Optional[Dict[str, PydanticAttribute]] = None
+    meta: Optional[Dict[str, Any]] = None
+    """
+    Metadata for the class to be included in a linkml_meta class attribute
+    """
 
     def _validators(self) -> Optional[Dict[str, PydanticValidator]]:
         if self.attributes is None:
@@ -548,6 +569,7 @@ class PydanticModule(TemplateModel):
     """
 
     template: ClassVar[str] = "module.py.jinja"
+    meta_exclude: ClassVar[str] = ["slots"]
 
     metamodel_version: Optional[str] = None
     version: Optional[str] = None
@@ -556,6 +578,10 @@ class PydanticModule(TemplateModel):
     imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
     enums: Dict[str, PydanticEnum] = Field(default_factory=dict)
     classes: Dict[str, PydanticClass] = Field(default_factory=dict)
+    meta: Optional[Dict[str, Any]] = None
+    """
+    Metadata for the schema to be included in a linkml_meta module-level instance of LinkMLMeta
+    """
 
     if int(PYDANTIC_VERSION[0]) >= 2:
 

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

@@ -7,4 +7,10 @@
     {%- if minimum_value != None %}, ge={{minimum_value}}{% endif -%}
     {%- if maximum_value != None %}, le={{maximum_value}}{% endif -%}
 {%- endif -%}
-)
+{%- if meta != None -%}
+    {%- if pydantic_ver == 1 -%}
+    , linkml_meta = {{ meta | pprint | indent(width=8) }}
+    {% else -%}
+    , json_schema_extra = { "linkml_meta": {{ meta | pprint | indent(width=8) }} }
+    {%- endif -%}
+{%- endif -%})

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

@@ -4,6 +4,10 @@ class {{ name }}({% if bases is string %}{{ bases }}{% else %}{{ bases | join(',
     {{ description | indent(width=4) }}
     """
     {% endif -%}
+    {% if meta != None %}
+    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({% if pydantic_ver == 1 %}__root__={% endif %}{{ meta | pprint | indent(width=8) }})
+
+    {% endif %}
     {%  if attributes or validators %}
         {% if attributes %}
             {% for attr in attributes.values() %}

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

@@ -7,18 +7,25 @@ version = "{{version if version else None}}"
 
 
 {{ base_model }}
-{% if enums %}
-    {% for e in enums.values() %}
 
-{{ e }}
-    {% endfor %}
-{% endif %}
 {% if injected_classes %}
     {% for c in injected_classes%}
 
 {{ c }}
     {% endfor %}
 {% endif %}
+{% if meta != None %}
+linkml_meta = LinkMLMeta({% if pydantic_ver == 1 %}__root__={% endif %}{{ meta | pprint | indent(width=4) }} )
+{% else %}
+linkml_meta = None
+{% endif %}
+{% if enums %}
+    {% for e in enums.values() %}
+
+{{ e }}
+    {% endfor %}
+{% endif %}
+
 {% for c in classes.values() %}
 
 {{ c }}

linkml/generators/pythongen.py

@@ -23,14 +23,7 @@ from linkml_runtime.linkml_model.meta import (
     TypeDefinition,
 )
 from linkml_runtime.utils.compile_python import compile_python
-from linkml_runtime.utils.formatutils import (
-    be,
-    camelcase,
-    sfx,
-    split_col,
-    underscore,
-    wrapped_annotation,
-)
+from linkml_runtime.utils.formatutils import be, camelcase, sfx, split_col, underscore, wrapped_annotation
 from linkml_runtime.utils.metamodelcore import builtinnames
 from rdflib import URIRef
 

linkml/generators/shaclgen.py

@@ -1,15 +1,17 @@
 import logging
 import os
 from dataclasses import dataclass
-from typing import Callable
+from typing import Callable, List
 
 import click
+from jsonasobj2 import JsonObj, as_dict
 from linkml_runtime.linkml_model.meta import ElementName
 from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.schemaview import SchemaView
+from linkml_runtime.utils.yamlutils import TypedNode, extended_float, extended_int, extended_str
 from rdflib import BNode, Graph, Literal, URIRef
 from rdflib.collection import Collection
-from rdflib.namespace import RDF, SH
+from rdflib.namespace import RDF, SH, XSD
 
 from linkml._version import __version__
 from linkml.generators.shacl.ifabsent_processor import IfAbsentProcessor
@@ -24,6 +26,8 @@ class ShaclGenerator(Generator):
     """True means add 'sh:closed=true' to all shapes, except of mixin shapes and shapes, that have parents"""
     suffix: str = None
     """parameterized suffix to be appended. No suffix per default."""
+    include_annotations: bool = False
+    """True means include all class / slot / type annotations in generated Node or Property shapes"""
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.1"
     valid_formats = ["ttl"]
@@ -83,6 +87,8 @@ class ShaclGenerator(Generator):
             list_node = BNode()
             Collection(g, list_node, [RDF.type])
             shape_pv(SH.ignoredProperties, list_node)
+            if c.annotations and self.include_annotations:
+                self._add_annotations(shape_pv, c)
             order = 0
             for s in sv.class_induced_slots(c.name):
                 # fixed in linkml-runtime 1.1.3
@@ -116,6 +122,12 @@ class ShaclGenerator(Generator):
 
                 all_classes = sv.all_classes()
                 if s.any_of:
+                    # It is not allowed to use any of and equals_string or equals_string_in in one
+                    # slot definition, as both are mapped to sh:in in SHACL
+                    if s.equals_string or s.equals_string_in:
+                        error = "'equals_string'/'equals_string_in' and 'any_of' are mutually exclusive"
+                        raise ValueError(f'{TypedNode.yaml_loc(s, suffix="")} {error}')
+
                     or_node = BNode()
                     prop_pv(SH["or"], or_node)
                     range_list = []
@@ -158,10 +170,17 @@ class ShaclGenerator(Generator):
                             add_simple_data_type(st_node_pv, r)
                             range_list.append(st_node)
                     Collection(g, or_node, range_list)
-
                 else:
                     prop_pv_literal(SH.hasValue, s.equals_number)
                     r = s.range
+                    if s.equals_string or s.equals_string_in:
+                        # Check if range is "string" as this is mandatory for "equals_string" and "equals_string_in"
+                        if r != "string":
+                            raise ValueError(
+                                f"slot: \"{slot_uri}\" - 'equals_string' and 'equals_string_in'"
+                                f" require range 'string' and not '{r}'"
+                            )
+
                     if r in all_classes:
                         self._add_class(prop_pv, r)
                         if sv.get_identifier_slot(r) is not None:
@@ -176,6 +195,14 @@ 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])
+                    if s.equals_string_in:
+                        # Map equal_string and equal_string_in to sh:in
+                        self._and_equals_string(g, prop_pv, s.equals_string_in)
 
                 ifabsent_processor.process_slot(prop_pv, s, class_uri)
 
@@ -206,9 +233,68 @@ class ShaclGenerator(Generator):
         rt = sv.get_type(r)
         if rt.uri:
             func(SH.datatype, URIRef(sv.get_uri(rt, expand=True)))
+            if rt.pattern:
+                func(SH.pattern, Literal(rt.pattern))
+            if rt.annotations and self.include_annotations:
+                self._add_annotations(func, rt)
         else:
             logging.error(f"No URI for type {rt.name}")
 
+    def _and_equals_string(self, g: Graph, func: Callable, values: List) -> None:
+        pv_node = BNode()
+        Collection(
+            g,
+            pv_node,
+            [Literal(v) for v in values],
+        )
+        func(SH["in"], pv_node)
+
+    def _add_annotations(self, func: Callable, item) -> None:
+        # TODO: migrate some of this logic to SchemaView
+        sv = self.schemaview
+        annotations = item.annotations
+        # item could be a class, slot or type
+        # annotation type could be dict (on types) or JsonObj (on slots)
+        if type(annotations) == JsonObj:
+            annotations = as_dict(annotations)
+        for a in annotations.values():
+            # If ':' is in the tag, treat it as a CURIE, otherwise string Literal
+            if ":" in a["tag"]:
+                N_predicate = URIRef(sv.expand_curie(a["tag"]))
+            else:
+                N_predicate = Literal(a["tag"], datatype=XSD.string)
+            # If the value is a string and ':' is in the value, treat it as a CURIE,
+            # otherwise treat as Literal with derived XSD datatype
+            if type(a["value"]) == extended_str and ":" in a["value"]:
+                N_object = URIRef(sv.expand_curie(a["value"]))
+            else:
+                N_object = Literal(a["value"], datatype=self._getXSDtype(a["value"]))
+
+            func(N_predicate, N_object)
+
+    def _getXSDtype(self, value):
+        value_type = type(value)
+        if value_type == bool:
+            return XSD.boolean
+        elif value_type == extended_str:
+            return XSD.string
+        elif value_type == extended_int:
+            return XSD.integer
+        elif value_type == extended_float:
+            # TODO: distinguish between xsd:decimal and xsd:double?
+            return XSD.decimal
+        else:
+            return None
+
+    def _and_equals_string(self, g: Graph, func: Callable, values: List) -> None:
+        pv_node = BNode()
+        Collection(
+            g,
+            pv_node,
+            [Literal(v) for v in values],
+        )
+        func(SH["in"], pv_node)
+
 
 def add_simple_data_type(func: Callable, r: ElementName) -> None:
     for datatype in list(ShaclDataType):
@@ -231,6 +317,12 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
     show_default=True,
     help="Use --suffix to append given string to SHACL class name (e. g. --suffix Shape: Person becomes PersonShape).",
 )
+@click.option(
+    "--include-annotations/--exclude-annotations",
+    default=False,
+    show_default=True,
+    help="Use --include-annotations to include annotations of slots, types, and classes in the generated SHACL shapes.",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate SHACL turtle from a LinkML model"""

linkml/generators/sqlalchemygen.py

@@ -7,12 +7,7 @@ from typing import List, Optional, Union
 
 import click
 from jinja2 import Template
-from linkml_runtime.linkml_model import (
-    Annotation,
-    ClassDefinition,
-    ClassDefinitionName,
-    SchemaDefinition,
-)
+from linkml_runtime.linkml_model import Annotation, ClassDefinition, ClassDefinitionName, SchemaDefinition
 from linkml_runtime.utils.compile_python import compile_python
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.schemaview import SchemaView
@@ -21,10 +16,7 @@ from sqlalchemy import Enum
 from linkml._version import __version__
 from linkml.generators.pydanticgen import PydanticGenerator
 from linkml.generators.pythongen import PythonGenerator
-from linkml.generators.sqlalchemy import (
-    sqlalchemy_declarative_template_str,
-    sqlalchemy_imperative_template_str,
-)
+from linkml.generators.sqlalchemy import sqlalchemy_declarative_template_str, sqlalchemy_imperative_template_str
 from linkml.generators.sqltablegen import SQLTableGenerator
 from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments

linkml/linter/rules.py

@@ -3,12 +3,7 @@ from abc import ABC, abstractmethod
 from functools import lru_cache
 from typing import Callable, Iterable, List
 
-from linkml_runtime.linkml_model import (
-    ClassDefinition,
-    ClassDefinitionName,
-    Element,
-    SlotDefinition,
-)
+from linkml_runtime.linkml_model import ClassDefinition, ClassDefinitionName, Element, SlotDefinition
 from linkml_runtime.utils.schemaview import SchemaView
 from prefixmaps.io.parser import load_multi_context
 

linkml/transformers/logical_model_transformer.py

@@ -32,6 +32,7 @@ from linkml.transformers.model_transformer import ModelTransformer
 from linkml.utils import logictools
 
 HERITABLE_METASLOT = [
+    # "multivalued",
     "range",
     "range_expression",
     "minimum_value",
@@ -102,7 +103,7 @@ class LogicalModelTransformer(ModelTransformer):
     >>> _ = sb.add_class("Person", slots={"age": {"range": "integer"}}, is_a="Thing")
     >>> _ = sb.add_class("Organization", slots={"category": {"range": "OrganizationType"}}, is_a="Thing")
     >>> _ = sb.add_enum("OrganizationType", ["commercial", "non-profit"])
-    >>> from linkml.transformers import LogicalModelTransformer
+    >>> from linkml.transformers.logical_model_transformer import LogicalModelTransformer
     >>> tr = LogicalModelTransformer()
     >>> tr.set_schema(sb.schema)
     >>> flat_schema = tr.transform()
@@ -153,8 +154,8 @@ class LogicalModelTransformer(ModelTransformer):
     attributes:
       entities:
         name: entities
-        multivalued: true
         range: Thing
+        multivalued: true
 
     ...
 
@@ -443,6 +444,9 @@ class LogicalModelTransformer(ModelTransformer):
                 logger.debug(f"Simplified member of: {x}")
                 simplified_att = self._from_logical_expression(x)
                 for k, v in simplified_att.__dict__.items():
+                    if v is None or v is False:
+                        if k in ["multivalued"]:
+                            continue
                     setattr(att, k, v)
 
     def _simplify_member_ofs(self, expr: logictools.Expression):

linkml/utils/schemaloader.py

@@ -235,6 +235,9 @@ class SchemaLoader:
             ):
                 self.raise_value_error(f"slot: {slot.name} - unrecognized range ({slot.range})", slot.range)
 
+            # check constraints for usage of equals_string and equals_string_in
+            self._check_equals_string(slot)
+
         # apply to --> mixins
         for cls in self.schema.classes.values():
             for apply_to_cls in cls.apply_to:
@@ -372,6 +375,9 @@ class SchemaLoader:
             ):
                 self.raise_value_error(f"slot: {slot.name} - unrecognized range ({slot.range})", slot.range)
 
+            # check constraints for usage of equals_string and equals_string_in
+            self._check_equals_string(slot)
+
         # Massage classes, propagating class slots entries domain back to the target slots
         for cls in self.schema.classes.values():
             if not isinstance(cls, ClassDefinition):
@@ -964,3 +970,24 @@ class SchemaLoader:
                 return rval
         else:
             return None
+
+    def _check_equals_string(self, slot: SlotDefinition):
+        if slot.equals_string or slot.equals_string_in:
+            # Range "string" mandatory for "equals_string" and "equals_string_in"
+            range = slot.range
+            if not range:
+                # range is not defined --> check default range
+                range = self.schema.default_range
+            if range != "string":
+                self.raise_value_error(
+                    f"slot: {slot.name} - 'equals_string' and 'equals_string_in' requires range "
+                    f"'string' and not range '{range}'",
+                    slot.range,
+                )
+            if slot.any_of:
+                # It is not allowed to use any of and equals_string or equals_string_in in one slot definition,
+                # as both are mapped to sh:in in SHACL
+                self.raise_value_error(
+                    f"slot: {slot.name} - 'equals_string'/'equals_string_in' and 'any_of' are mutually exclusive",
+                    slot.name,
+                )

linkml/utils/schemasynopsis.py

@@ -21,15 +21,7 @@ from linkml_runtime.utils.metamodelcore import empty_dict
 from linkml_runtime.utils.yamlutils import TypedNode
 from rdflib import URIRef
 
-from linkml.utils.typereferences import (
-    ClassType,
-    EnumType,
-    References,
-    RefType,
-    SlotType,
-    SubsetType,
-    TypeType,
-)
+from linkml.utils.typereferences import ClassType, EnumType, References, RefType, SlotType, SubsetType, TypeType
 
 
 def empty_references() -> field:

linkml/validator/__init__.py

@@ -11,9 +11,7 @@ from typing import Any, Optional, Union
 from linkml_runtime.linkml_model import SchemaDefinition
 from linkml_runtime.loaders import yaml_loader
 
-from linkml.validator.loaders import (
-    default_loader_for_file,
-)
+from linkml.validator.loaders import default_loader_for_file
 from linkml.validator.plugins import JsonschemaValidationPlugin
 from linkml.validator.report import ValidationReport
 from linkml.validator.validator import Validator

linkml/validator/plugins/__init__.py

@@ -4,9 +4,7 @@ on data instances. Instances of these classes should be provided when constructi
 :class:`linkml.validator.Validator` instance.
 """
 
-from linkml.validator.plugins.jsonschema_validation_plugin import (
-    JsonschemaValidationPlugin,
-)
+from linkml.validator.plugins.jsonschema_validation_plugin import JsonschemaValidationPlugin
 from linkml.validator.plugins.pydantic_validation_plugin import PydanticValidationPlugin
 from linkml.validator.plugins.recommended_slots_plugin import RecommendedSlotsPlugin
 from linkml.validator.plugins.validation_plugin import ValidationPlugin

{linkml-1.7.10.dist-info → linkml-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.7.10
+Version: 1.8.0
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -36,7 +36,7 @@ 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.4)
+Requires-Dist: linkml-runtime (==1.8.0)
 Requires-Dist: openpyxl
 Requires-Dist: parse
 Requires-Dist: prefixcommons (>=0.1.7)

{linkml-1.7.10.dist-info → linkml-1.8.0.dist-info}/RECORD

@@ -6,9 +6,9 @@ linkml/generators/__init__.py,sha256=dQ2EUKy_MctEVEzbC3XzEJL5YmYwjYfsa44mG2zKn7g
 linkml/generators/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml/generators/common/type_designators.py,sha256=lgVcIRJJ-yCvVGeP9U_gQZpm77UmJBQo9Bh3lGJITno,1956
 linkml/generators/csvgen.py,sha256=R8VQdWXj43LNf5isJElo3MStsiNBSSF4ywIRS1c3_v0,3243
-linkml/generators/docgen/class.md.jinja2,sha256=bz5A46HOIPkUVbzPGorg64NNhr66zK0hCCekSfRPErY,3787
+linkml/generators/docgen/class.md.jinja2,sha256=-JmjYHgYOaaBYd5r-Tr5dkk0CLM_lX0kHdocPQtRsjU,3504
 linkml/generators/docgen/class_diagram.md.jinja2,sha256=gzskx4hOpU_s6BqOXdYZ9DwKxuClnsEgDzPurm30PeY,3469
-linkml/generators/docgen/common_metadata.md.jinja2,sha256=zy8Ua3gDtAAq8VA3e3O3ft9W7eJopVZaq5efP8LU_hU,1321
+linkml/generators/docgen/common_metadata.md.jinja2,sha256=gy9J8rghBfKDKimwtHj_XuHY4PJRRYHLXVlBHqWrUzU,1604
 linkml/generators/docgen/enum.md.jinja2,sha256=mXnUrRkleY2bOTEyAZ5c4pcUnqhs6BNa8a-4LVve-eo,1014
 linkml/generators/docgen/index.md.jinja2,sha256=wXUYTmayPLFltC0vbGE_Mf6m3GkkWav7FOEjCvEpHp4,1466
 linkml/generators/docgen/index.tex.jinja2,sha256=Go_EA-_N4JUpbOYbk3OY11mz5yV70VF2l2sMtgIPWw4,501
@@ -18,9 +18,9 @@ linkml/generators/docgen/subset.md.jinja2,sha256=EPln_fjlhlkmwEGEp2iPX-9Xm2vVodP
 linkml/generators/docgen/type.md.jinja2,sha256=QmCMJZrFwP33eHkggBVtypbyrxTb-XZn9vHOYojVaYk,635
 linkml/generators/docgen.py,sha256=QECBmOAiVr-DsUYOLmqapESSB_CiNoiHt_3vjiZCrUs,36396
 linkml/generators/dotgen.py,sha256=kzp1EYtF8bBqOuycJokDmsvHVDVkkW-J-6-MiUhwJH0,5013
-linkml/generators/erdiagramgen.py,sha256=xCnxIldDYZ7xnQ-vLaXlH3FH8MH3cxu-E0j8it-lyJE,10153
+linkml/generators/erdiagramgen.py,sha256=7W010ngoHrk-BjhCEmpHyySPImLXIOTEBGO70hOUOH8,11341
 linkml/generators/excelgen.py,sha256=3ILAeIHeYngNpPf3Ad7CXoHOLQ9KSiYcX5HdwHhQeQE,7696
-linkml/generators/golanggen.py,sha256=1seIQiKq-ASZoHTf7xoPd0zUQ4YCPkxoKnUwgAIttPo,5811
+linkml/generators/golanggen.py,sha256=rDiDFyZBZ6_JygCEdpbKrohQCScvBlWi17AcoR6Qi3g,5790
 linkml/generators/golrgen.py,sha256=OUBYRWicP7G7lrPu1VrxumbVpx3CBJal-o2imyeP05M,3437
 linkml/generators/graphqlgen.py,sha256=ClJdD6fVjBI8rsIJ3DIuwdQScAJG0gYYKwS8SrFqVZk,2149
 linkml/generators/javagen/example_template.java.jinja2,sha256=ec4CVTv_0zS7V5Y-1E6H4lRraya10gfX7BEMBlu38X4,444
@@ -35,37 +35,38 @@ linkml/generators/markdowngen.py,sha256=mwydWkrF-WzsTiKwJqqe9NUya5VaTj7ywKqodP85
 linkml/generators/namespacegen.py,sha256=vVcIyM0zlKd7XRvtdzwTwHjG4Pg49801gy4FUmjJlqQ,6450
 linkml/generators/oocodegen.py,sha256=r73QI08ajbTZTobc9OIG6BMWZft3zdu76vKVR33pyYg,7774
 linkml/generators/owlgen.py,sha256=NHIcL1d79WoeqfiZRj6kRk5aTXcQ6JDNXV_VAtH6Vt0,57554
-linkml/generators/plantumlgen.py,sha256=8fQG_IQSn_KdRG-vaQPXHpU9rvRWBggymdu-uK_7Oqo,14936
+linkml/generators/plantumlgen.py,sha256=2e4ejw0B72Sl_-mipgpKz743LVMs0kRZc8E0MK7gxFY,14919
 linkml/generators/prefixmapgen.py,sha256=w8gMCFOI0DmZsNvo9IkbhOqVWqqWYEN6SXnAP3BgFSk,4240
 linkml/generators/projectgen.py,sha256=OuT_AneoZFNMCn50GllfZafadUHt50u61JcftM2eed4,9750
 linkml/generators/protogen.py,sha256=i4sEhNdAiFFP12fwfRdype1MX8yU-E5fF7XzkcpBCd0,2512
 linkml/generators/pydanticgen/__init__.py,sha256=uKGaaQSaeKqinHImXGFE448i-t8Oi0No8suIO76sep8,629
-linkml/generators/pydanticgen/array.py,sha256=1QWWgz46yVmWkdNauI6Kjkbx3kexp-l210nOILoHJ18,19506
-linkml/generators/pydanticgen/black.py,sha256=c-Hgaao9hd4nPMU9w0Hmg2j4Wc81IcY0zAfppQPr1cM,721
+linkml/generators/pydanticgen/array.py,sha256=EYqAkT2_wE82kZ-niUWAC5U3V8EvjjyfSH7tz5GYKWo,19461
+linkml/generators/pydanticgen/black.py,sha256=BaJ7b-kMUbIN_cKRT3yCaMEbFwxzj1_U7w4fKQnkL44,723
 linkml/generators/pydanticgen/build.py,sha256=Ia8qy4C16b-KqO_fw4tGQW_Eo4grCVyX7RsuJ3uRTtk,2681
-linkml/generators/pydanticgen/pydanticgen.py,sha256=7X56SDTEzWt8irqdWOmYUfiBcAlOlfRUbTK3JhYX_JU,30184
-linkml/generators/pydanticgen/template.py,sha256=fAqRofLm7N94xUqXjkStdmugcxGQfiioGkxdIhLByik,19990
-linkml/generators/pydanticgen/templates/attribute.py.jinja,sha256=AlH_QFJJkONpzXQRGqnW4ufmjp9s9E7Q9W5r8ykNGeQ,443
+linkml/generators/pydanticgen/includes.py,sha256=PIVbACrtqQS6LFrXqQsJC6dQUcGBM3uY4E4qLQWJrnk,998
+linkml/generators/pydanticgen/pydanticgen.py,sha256=WZxFfLvXhHXVtDQpLjMf63eoBMUxcW0oEMS14jbDOWo,34458
+linkml/generators/pydanticgen/template.py,sha256=HESLY1Rd7N_e92dqrh_fif_yp3oDl0n1UAghklMyphA,20982
+linkml/generators/pydanticgen/templates/attribute.py.jinja,sha256=S_T-M7n_eeM3LW5gQUuTPH1-Oc1CEtL7Bve7qAFouYQ,688
 linkml/generators/pydanticgen/templates/base_model.py.jinja,sha256=48y64MnC9rjNSV-nKLMeDuHN4gm15UsInhnKxh65zoM,834
-linkml/generators/pydanticgen/templates/class.py.jinja,sha256=RIdkqdZS9rDILUuVqDIAWK_vATGkirLbPhdHSyHDAbY,565
+linkml/generators/pydanticgen/templates/class.py.jinja,sha256=V_lyvFcZ9QhlKZi2bL5iff8RjHir2SQTTypOzQMOfmk,744
 linkml/generators/pydanticgen/templates/conditional_import.py.jinja,sha256=YheknDrxvepiJUzeItSL5aSbAkCdR1k0a6m6aTA4qNM,240
 linkml/generators/pydanticgen/templates/enum.py.jinja,sha256=572XFQyEMZfL-G_Cj68T-NI_mUnDoFOAVJOGIKu2Hb8,338
 linkml/generators/pydanticgen/templates/footer.py.jinja,sha256=WuWGJjkWDQcEPL2bGk5fdGuhO0gQRUJzpo4CQHHxQNQ,385
 linkml/generators/pydanticgen/templates/imports.py.jinja,sha256=d1XFna2eOpkH8cgJML3vXwqGcocczvOcrbg6jjd4kP0,945
-linkml/generators/pydanticgen/templates/module.py.jinja,sha256=SkmtWtQS7D-xBiZI-sFiYC3WYPKi3VJCj_KtaMVxexM,438
+linkml/generators/pydanticgen/templates/module.py.jinja,sha256=nymjtSX4jqV9deSsXrsh1HWR90ygECHE4CV9MCyNrTY,615
 linkml/generators/pydanticgen/templates/validator.py.jinja,sha256=Yo4dubQal-HwEoJKztQkLYM5qCz1I8na2oaDlXuEpwU,532
-linkml/generators/pythongen.py,sha256=IVloJ6v7QE7mdHygz0kZmcJ6D61usKffeyBmZjkArng,52879
+linkml/generators/pythongen.py,sha256=CiLmc964siGeJWZC_bOffsqrSnJ5qzn7Eu961C47xgo,52850
 linkml/generators/rdfgen.py,sha256=eQi3XXjWk6xliTLncQ4G0VYzGCJwCU_FFG-O7tA8DSA,2959
 linkml/generators/shacl/__init__.py,sha256=O-M-wndKw8rMW-U8X3QCNHal-ErXP6uXZqxiQSa77l4,108
 linkml/generators/shacl/ifabsent_processor.py,sha256=kV9BGA2ZPXLRfaFuW0o4jpkATvGggvrqpAo9c1UqWNE,2193
 linkml/generators/shacl/shacl_data_type.py,sha256=BT3C9tdFyBQnuucPN7YQiFAKEa9yuzy-Q26X6dmOXgo,1827
-linkml/generators/shaclgen.py,sha256=B9BkCzOQULjpCN10jbvazY6_WEkeVGO8lxEhr6pQ3_A,8849
+linkml/generators/shaclgen.py,sha256=kgJ3VaVM0_7XBr5cvqgob6wjEarNINZzpC4FK61sC9M,13157
 linkml/generators/shexgen.py,sha256=MhB1HidCREMCJcDGBqutFQ0gWKKz7aSVw-0s-IHUMm4,9930
 linkml/generators/sparqlgen.py,sha256=c7x8GFChKWprBx4rToSnu9qN8OleWTCenVUdZ8XSTWM,6138
 linkml/generators/sqlalchemy/__init__.py,sha256=mb9AC1rIFkSiNZhhG0TAk45ol9PjS1XvsrvCjgfVUpQ,249
 linkml/generators/sqlalchemy/sqlalchemy_declarative_template.py,sha256=X_Ws1NUBikMI5HuNgEhl_PIeWM-B-c2B0W9KUBH4QTg,2542
 linkml/generators/sqlalchemy/sqlalchemy_imperative_template.py,sha256=u4ZpponG1h6XROrOHGOf_0H2e6xL1_s8twAOA-gx94A,1622
-linkml/generators/sqlalchemygen.py,sha256=5J9eQhTz7Ug-7WhZPv6zIaAbf7xlLi-0xMequ67pvgA,9320
+linkml/generators/sqlalchemygen.py,sha256=boXn_tlkbZ_a5TJYoXvdlKzABNwD-Jn5ld9IAbtzWm4,9286
 linkml/generators/sqltablegen.py,sha256=87057FJi9EUVPXOjRfHuSqY0lKmepXRNQsose2fGts4,12343
 linkml/generators/sssomgen.py,sha256=yur3q7so9uwIELWZaZRzkJwNbz_ppBL7IQki9XLIM3k,6879
 linkml/generators/string_template.md,sha256=kRcfic6entgIaJdpSg6GF3jcjC9wbKsCVM6wVT2qipc,1788
@@ -89,11 +90,11 @@ linkml/linter/formatters/markdown_formatter.py,sha256=sumF2MNJYL5oipLwCftCr3AiaC
 linkml/linter/formatters/terminal_formatter.py,sha256=xmNwlRieVCssRt3fpnNP5WWw_YXGmaBsbxFoMWufy5M,2085
 linkml/linter/formatters/tsv_formatter.py,sha256=1VW-1Tv16mwhIDpHdExYpJJR3z42K5_XK2C-4mmYYdE,871
 linkml/linter/linter.py,sha256=qfVV-vFT7bUJ2BmmDQteD7Jz8HZ-CNDSvnkyhJ-54H0,5113
-linkml/linter/rules.py,sha256=EuZTHtrU9YndAf2vw6QknGZSVFgsbydStsQmrUCwTKk,11502
+linkml/linter/rules.py,sha256=Eg_-lIX1KPsCp3PHdPcBiHmSS5qAVZkHbw5LURfkfXk,11481
 linkml/reporting/__init__.py,sha256=Jo0V_nyEcnWhMukMW-bqW9dlbgCfaRlWm3CO-XzgU84,92
 linkml/reporting/model.py,sha256=-10yNfk8wuRC48ZI-akrWvtlJ9a6RYWET2TzlZV3XXo,8622
 linkml/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-linkml/transformers/logical_model_transformer.py,sha256=Luc8cKWIGrRAXQ9DSLA03fgpIolLpsTT19OV9Coolvk,26522
+linkml/transformers/logical_model_transformer.py,sha256=z-1nyD0d8LYJeAPWRn29p-S4Hgmvjocfcj0VrHTAs2c,26703
 linkml/transformers/model_transformer.py,sha256=tK_MpRDI-q2qfe8KHT6qJHP8ZruKjYx1FcM-Fnjse-E,678
 linkml/transformers/relmodel_transformer.py,sha256=aiSI2xaqRz4f0Z_0WFaBP5bknzX0pTnvxsR5mESFysg,18857
 linkml/transformers/schema_renamer.py,sha256=DYRbgL9j41M9FdbHYLY3u4YIdDM98laD3cv_lHcgWHQ,5275
@@ -112,12 +113,12 @@ linkml/utils/mergeutils.py,sha256=QVm2iQB4v_L2rSvPBsPe9C865R03BgV3TzlPoTTTwWQ,90
 linkml/utils/rawloader.py,sha256=nUB8Gfn8yEVwyo6bx0TtB2mBGkilC-fybi0xvQ73Gks,4417
 linkml/utils/schema_builder.py,sha256=4qhrur8O0xRZnPm7H1h2BZmTkut5R4q-IE_1KKiHy_c,9937
 linkml/utils/schema_fixer.py,sha256=Uz8M3AOQ_BputJr1f6lbfk1iyvmANUNG80-0B3BQKJ8,16761
-linkml/utils/schemaloader.py,sha256=5fLM99v6RZ0OW4JHA0UAd_mtS_2HNubXAjlF5v8vHcw,46093
-linkml/utils/schemasynopsis.py,sha256=jKf5ZJxpNgSZ5x9oAcdGO3m1IwzcIU2Ni1ugm0SQq1g,18447
+linkml/utils/schemaloader.py,sha256=dWZO044p_UcUWnrd8HZ-NsbLXQ9cA6c8HKfNI9-qH2A,47388
+linkml/utils/schemasynopsis.py,sha256=j7sNt6j-E3rmf-1qEo351Kth2kltt6crQV-dxJAGCUE,18414
 linkml/utils/sqlutils.py,sha256=Cwoaz44MLcvAGUEBshT4jtn0Z3w7jVOp85zGkd6FTHY,17071
 linkml/utils/typereferences.py,sha256=8Yfuz9-HAwOPoJLbIcO_sY9zf32hvPRzGeSOzECfMWA,2232
 linkml/utils/validation.py,sha256=eLw1-d8x3N1V14bSc6H_mJJXo59ryKvvUIBcOJ1dVMw,1438
-linkml/validator/__init__.py,sha256=djKc1IyxGKvVYaX5jSxsqjfcEYaw3rFgKbFJxI2wDNk,5002
+linkml/validator/__init__.py,sha256=u0CeorIw50Qqwa60-lIFsJXg-sOdfo90hqvLpyvvwo4,4993
 linkml/validator/cli.py,sha256=uVe_tbBzsK-4BNboE5zRyohS_dEs5Nl1gbhklrzOEpw,7605
 linkml/validator/loaders/__init__.py,sha256=FjUqEfBHeT5PEMBEZ9XwpclyQOysr4OCI1M0w_MYPVc,1165
 linkml/validator/loaders/delimited_file_loader.py,sha256=fdh61ZMPTfH29_DM93f5dY0jLP7KQPNh_QAHZppsdNw,2616
@@ -125,7 +126,7 @@ linkml/validator/loaders/json_loader.py,sha256=Qy42naS2clb0fNXbUushckRu5AIX32b3U
 linkml/validator/loaders/loader.py,sha256=YKQXmSZhCymvvb2Dbr4lVCKVDt-lOIayzRD7CWrdsJI,559
 linkml/validator/loaders/passthrough_loader.py,sha256=fQvBZqzGnpdwpZio4Mbehmsb6ePpzcacHPuR1QWuhFM,525
 linkml/validator/loaders/yaml_loader.py,sha256=ZsMz-oGDkX9oPEOVcKnFRGhU9q0fKoHcL6BLOkCeB4c,914
-linkml/validator/plugins/__init__.py,sha256=F7Un7bfdpSRXvk8LTb7Z4Q22rCtJJKjNkqUfIVLFtT8,702
+linkml/validator/plugins/__init__.py,sha256=0ifiDqpcXVy4X7OJFm7FMYi1-6E06avNIIk9R0c6nD8,693
 linkml/validator/plugins/jsonschema_validation_plugin.py,sha256=c3OjvLR5m83vppsDfkrS9nMXma_ogUxXpZuM_JIUVM4,2634
 linkml/validator/plugins/pydantic_validation_plugin.py,sha256=C-Vp74bz5oqp5V-iuhXW8p0PPDoFY8NCU5x36Ur5Og4,1985
 linkml/validator/plugins/recommended_slots_plugin.py,sha256=kOdoYQyye47nLA7BjorVmydS84nGpiVy3MoCbPq1Ymo,2308
@@ -142,8 +143,8 @@ linkml/workspaces/datamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 linkml/workspaces/datamodel/workspaces.py,sha256=4HdkqweGNfMPqnB1_Onc9DcTfkhoagTRcqruh08nRoI,14905
 linkml/workspaces/datamodel/workspaces.yaml,sha256=EjVrwPpeRZqJRjuGyyDRxxFzuv55SiLIXPBRUG6HStU,4233
 linkml/workspaces/example_runner.py,sha256=hDk2RGxRE5-WYNriWknugtbm3Mhn8bFcAcXGMlkYxVk,11705
-linkml-1.7.10.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.7.10.dist-info/METADATA,sha256=yPm-MeDgZDVgX_q3NF46RfunUoxWV2Mc5W6-ZkE6x_Y,3725
-linkml-1.7.10.dist-info/entry_points.txt,sha256=7haDkIbyC7ZLhm5z-e3BhrLJpY2xoW1yuD8Y7QPNtVg,2093
-linkml-1.7.10.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.7.10.dist-info/RECORD,,
+linkml-1.8.0.dist-info/entry_points.txt,sha256=7haDkIbyC7ZLhm5z-e3BhrLJpY2xoW1yuD8Y7QPNtVg,2093
+linkml-1.8.0.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.8.0.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.8.0.dist-info/METADATA,sha256=ImZiqQezJfM8leU0WgCimYjcJXydh1XO8T22tlC9zpw,3724
+linkml-1.8.0.dist-info/RECORD,,