linkml 1.7.9__py3-none-any.whl → 1.7.11rc1__py3-none-any.whl

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,7 +20,7 @@ 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
 
@@ -37,6 +30,7 @@ from linkml.generators.common.type_designators import (
     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 +79,7 @@ DEFAULT_IMPORTS = (
         module="typing",
         objects=[
             ObjectImport(name="Any"),
+            ObjectImport(name="ClassVar"),
             ObjectImport(name="List"),
             ObjectImport(name="Literal"),
             ObjectImport(name="Dict"),
@@ -100,6 +95,7 @@ DEFAULT_IMPORTS = (
             ObjectImport(name="BaseModel"),
             ObjectImport(name="ConfigDict"),
             ObjectImport(name="Field"),
+            ObjectImport(name="RootModel"),
             ObjectImport(name="field_validator"),
         ],
         alternative=Import(
@@ -109,6 +105,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 +235,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 +559,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 +619,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 +744,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 +769,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:
@@ -723,7 +811,7 @@ Available templates to override:
 @click.option(
     "--pydantic-version",
     type=click.IntRange(1, 2),
-    default=1,
+    default=int(PYDANTIC_VERSION[0]),
     help="Pydantic version to use (1 or 2)",
 )
 @click.option(
@@ -739,6 +827,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(
@@ -750,8 +844,9 @@ def cli(
     classvars=True,
     slots=True,
     array_representations=list("list"),
-    pydantic_version=1,
+    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 +872,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/shaclgen.py

@@ -130,7 +130,7 @@ class ShaclGenerator(Generator):
 
                             self._add_class(cl_node_pv, r)
                             range_list.append(class_node)
-                        elif r in sv.all_types().values():
+                        elif r in sv.all_types():
                             t_node = BNode()
 
                             def t_node_pv(p, v):
@@ -168,7 +168,7 @@ class ShaclGenerator(Generator):
                             prop_pv(SH.nodeKind, SH.IRI)
                         else:
                             prop_pv(SH.nodeKind, SH.BlankNodeOrIRI)
-                    elif r in sv.all_types().values():
+                    elif r in sv.all_types():
                         self._add_type(prop_pv, r)
                     elif r in sv.all_enums():
                         self._add_enum(g, prop_pv, r)
@@ -201,10 +201,11 @@ class ShaclGenerator(Generator):
         func(SH["in"], pv_node)
 
     def _add_type(self, func: Callable, r: ElementName) -> None:
+        func(SH.nodeKind, SH.Literal)
         sv = self.schemaview
         rt = sv.get_type(r)
         if rt.uri:
-            func(SH.datatype, rt.uri)
+            func(SH.datatype, URIRef(sv.get_uri(rt, expand=True)))
         else:
             logging.error(f"No URI for type {rt.name}")
 

{linkml-1.7.9.dist-info → linkml-1.7.11rc1.dist-info}/METADATA

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

{linkml-1.7.9.dist-info → linkml-1.7.11rc1.dist-info}/RECORD

@@ -41,25 +41,26 @@ linkml/generators/projectgen.py,sha256=OuT_AneoZFNMCn50GllfZafadUHt50u61JcftM2ee
 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/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=RHRMRXPpR4tFoUcKM3S58NbU1VI6uXtcZ0wh6zzNZRg,30138
-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=S5t9RhS3R7nhE4DmYX--e41th9sIyrO2T3SdBPtxIJE,34471
+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/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=unhdoNDe9Tp66oGj3LnRud6emN14jtaf2jtuVtxQ2NM,8800
+linkml/generators/shaclgen.py,sha256=B9BkCzOQULjpCN10jbvazY6_WEkeVGO8lxEhr6pQ3_A,8849
 linkml/generators/shexgen.py,sha256=MhB1HidCREMCJcDGBqutFQ0gWKKz7aSVw-0s-IHUMm4,9930
 linkml/generators/sparqlgen.py,sha256=c7x8GFChKWprBx4rToSnu9qN8OleWTCenVUdZ8XSTWM,6138
 linkml/generators/sqlalchemy/__init__.py,sha256=mb9AC1rIFkSiNZhhG0TAk45ol9PjS1XvsrvCjgfVUpQ,249
@@ -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.9.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.7.9.dist-info/METADATA,sha256=BMYy_g5uDJO5NGDlD8Xvdl_uGqFBFwMuys3T_NGc7og,3724
-linkml-1.7.9.dist-info/entry_points.txt,sha256=7haDkIbyC7ZLhm5z-e3BhrLJpY2xoW1yuD8Y7QPNtVg,2093
-linkml-1.7.9.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.7.9.dist-info/RECORD,,
+linkml-1.7.11rc1.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.7.11rc1.dist-info/METADATA,sha256=rN4JFH3t8f6Mn3SjZlQYFUsj3leDC8GE47VrmWGRDA4,3728
+linkml-1.7.11rc1.dist-info/entry_points.txt,sha256=7haDkIbyC7ZLhm5z-e3BhrLJpY2xoW1yuD8Y7QPNtVg,2093
+linkml-1.7.11rc1.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.7.11rc1.dist-info/RECORD,,