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

linkml/generators/excelgen.py

@@ -1,6 +1,6 @@
 import logging
-import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from pathlib import Path
 from typing import List
 
 import click
@@ -8,78 +8,80 @@ from linkml_runtime.utils.schemaview import SchemaView
 from openpyxl import Workbook
 from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
-from openpyxl.worksheet.worksheet import Worksheet
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.helpers import convert_to_snake_case
 
 
 @dataclass
 class ExcelGenerator(Generator):
     # ClassVars
-    generatorname = os.path.basename(__file__)
+    generatorname = Path(__file__).name
     generatorversion = "0.1.1"
     valid_formats = ["xlsx"]
     uses_schemaloader = False
     requires_metamodel = False
 
+    split_workbook_by_class: bool = field(default_factory=lambda: False)
+
     def __post_init__(self) -> None:
         super().__post_init__()
         self.logger = logging.getLogger(__name__)
         self.schemaview = SchemaView(self.schema)
 
-    def create_workbook(self, workbook_name: str) -> Workbook:
+    def create_workbook(self, workbook_path: Path) -> Workbook:
         """
         Creates an Excel workbook using the openpyxl library and returns it.
 
-        :param workbook_name: Name of the workbook to be created.
+        :param workbook_path: Path of the workbook to be created.
         :return: An openpyxl Workbook object representing the newly created workbook.
         """
         workbook = Workbook()
-        workbook.title = workbook_name
+        workbook.save(workbook_path)
         return workbook
 
-    def get_workbook_name(self, workbook: Workbook) -> str:
-        """
-        Returns the name of the given workbook.
-
-        :param workbook: The workbook whose name should be returned.
-        :return: Name of the workbook.
-        """
-        return workbook.title
-
-    def remove_worksheet_by_name(self, workbook: Workbook, worksheet_name: str) -> None:
-        """
-        Remove worksheet from workbook by name.
-        """
-        worksheet = workbook[worksheet_name]
-        workbook.remove(worksheet)
-
-    def create_worksheet(self, workbook: Workbook, worksheet_name: str) -> Worksheet:
+    def create_workbook_and_worksheets(self, output_path: Path, classes: List[str]) -> None:
         """
-        Creates an Excel worksheet with the given name in the given workbook.
+        Creates a workbook with worksheets for each class.
 
-        :param workbook: The workbook to which the worksheet should be added.
-        :param worksheet_name: Name of the worksheet to be created.
+        :param output_path: The path where the workbook should be created.
+        :param classes: List of class names for which worksheets should be created.
         """
-        worksheet = workbook.create_sheet(worksheet_name)
-        workbook_name = self.get_workbook_name(workbook)
-        workbook.save(workbook_name)
+        workbook = self.create_workbook(output_path)
+        workbook.remove(workbook.active)
+        sv = self.schemaview
 
-        return worksheet
+        for cls_name in classes:
+            cls = sv.get_class(class_name=cls_name, imports=self.mergeimports)
+            if not cls.mixin and not cls.abstract:
+                workbook.create_sheet(cls_name)
 
-    def create_schema_worksheets(self, workbook: str) -> None:
-        """
-        Creates worksheets in a given Excel workbook based on the classes in the
-        schema.
+                # Add columns to the worksheet for the current class
+                slots = [s.name for s in sv.class_induced_slots(cls_name, self.mergeimports)]
+                self.add_columns_to_worksheet(workbook, cls_name, slots)
+                workbook.save(output_path)
 
-        :param workbook: The workbook to which the worksheet should be added.
-        """
-        sv = self.schemaview
-        for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
-            if not cls.mixin and not cls.abstract:
-                self.create_worksheet(workbook, cls_name)
+                # Add enum validation for columns with enum types
+                enum_list = list(sv.all_enums(imports=self.mergeimports).keys())
+                for s in sv.class_induced_slots(cls_name, self.mergeimports):
+                    if s.range in enum_list:
+                        pv_list = list(sv.get_enum(s.range).permissible_values.keys())
+
+                        # Check if the total length of permissible values is <= 255 characters
+                        enum_length = sum(len(value) for value in pv_list)
+                        if enum_length <= 255:
+                            self.column_enum_validation(workbook, cls_name, s.name, pv_list)
+                        else:
+                            self.logger.warning(
+                                f"'{s.range}' has permissible values with total "
+                                "length > 255 characters. Dropdowns may not work properly "
+                                f"in {output_path}"
+                            )
+                    workbook.save(output_path)
+
+        workbook.save(output_path)
+        if self.split_workbook_by_class:
+            self.logger.info(f"The Excel workbooks have been written to {output_path}")
 
     def add_columns_to_worksheet(self, workbook: Workbook, worksheet_name: str, sheet_headings: List[str]) -> None:
         """
@@ -96,10 +98,6 @@ class ExcelGenerator(Generator):
         for i, heading in enumerate(sheet_headings):
             worksheet.cell(row=1, column=i + 1, value=heading)
 
-        # Save the changes to the workbook
-        workbook_name = self.get_workbook_name(workbook)
-        workbook.save(workbook_name)
-
     def column_enum_validation(
         self,
         workbook: Workbook,
@@ -129,48 +127,52 @@ class ExcelGenerator(Generator):
 
         dv.add(f"{column_letter}2:{column_letter}1048576")
 
-        workbook_name = self.get_workbook_name(workbook)
-        workbook.save(workbook_name)
-
     def serialize(self, **kwargs) -> str:
-        self.output = (
-            os.path.abspath(convert_to_snake_case(self.schema.name) + ".xlsx") if not self.output else self.output
-        )
+        sv = self.schemaview
+        classes_to_process = [
+            cls_name
+            for cls_name, cls in sv.all_classes(imports=self.mergeimports).items()
+            if not cls.mixin and not cls.abstract
+        ]
 
-        workbook = self.create_workbook(self.output)
-        self.remove_worksheet_by_name(workbook, "Sheet")
-        self.create_schema_worksheets(workbook)
+        if self.split_workbook_by_class:
+            output_path = Path(self.schema.name + "_worksheets") if not self.output else Path(self.output)
+            output_path = output_path.absolute()
 
-        sv = self.schemaview
-        for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
-            if not cls.mixin and not cls.abstract:
-                slots = [s.name for s in sv.class_induced_slots(cls_name, imports=self.mergeimports)]
-                self.add_columns_to_worksheet(workbook, cls_name, slots)
+            if not output_path.is_dir():
+                output_path.mkdir(parents=True, exist_ok=True)
 
-        enum_list = [e_name for e_name, _ in sv.all_enums(imports=self.mergeimports).items()]
-        for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
-            if not cls.mixin and not cls.abstract:
-                for s in sv.class_induced_slots(cls_name, imports=self.mergeimports):
-                    if s.range in enum_list:
-                        pv_list = []
-                        for pv_name, _ in sv.get_enum(s.range).permissible_values.items():
-                            pv_list.append(pv_name)
-                        self.column_enum_validation(workbook, cls_name, s.name, pv_list)
-        self.logger.info(f"The Excel workbook has been written to {self.output}")
+            for cls_name in classes_to_process:
+                cls_output_path = output_path.joinpath(f"{cls_name}.xlsx")
+                self.create_workbook_and_worksheets(cls_output_path, [cls_name])
+                self.logger.info(f"The Excel workbook for class '{cls_name}' has been written to {cls_output_path}")
+        else:
+            output_path = Path(self.schema.name + ".xlsx") if not self.output else Path(self.output)
+            output_path = output_path.absolute()
+
+            self.create_workbook_and_worksheets(output_path, classes_to_process)
+
+            self.logger.info(f"The Excel workbook has been written to {output_path}")
 
 
 @shared_arguments(ExcelGenerator)
 @click.command()
+@click.option(
+    "--split-workbook-by-class",
+    is_flag=True,
+    default=False,
+    help="""Split model into separate Excel workbooks/files, one for each class""",
+)
 @click.option(
     "-o",
     "--output",
     type=click.Path(),
-    help="""Name of Excel spreadsheet to be created""",
+    help="""Name of Excel spreadsheet to be created, or name of directory to create split workbooks in""",
 )
 @click.version_option(__version__, "-V", "--version")
-def cli(yamlfile, **kwargs):
+def cli(yamlfile, split_workbook_by_class, **kwargs):
     """Generate Excel representation of a LinkML model"""
-    ExcelGenerator(yamlfile, **kwargs).serialize(**kwargs)
+    ExcelGenerator(yamlfile, split_workbook_by_class=split_workbook_by_class, **kwargs).serialize(**kwargs)
 
 
 if __name__ == "__main__":

linkml/generators/pydanticgen.py

@@ -108,7 +108,46 @@ class {{ e.name }}(str{% if e['values'] %}, Enum{% endif %}):
 {% endfor %}
 """
     ### CLASSES ###
-    template += """
+    if pydantic_ver == "1":
+        template += """
+{%- for c in schema.classes.values() %}
+class {{ c.name }}
+    {%- if class_isa_plus_mixins[c.name] -%}
+        ({{class_isa_plus_mixins[c.name]|join(', ')}})
+    {%- else -%}
+        (ConfiguredBaseModel)
+    {%- endif -%}
+                  :
+    {% if c.description -%}
+    \"\"\"
+    {{ c.description }}
+    \"\"\"
+    {%- endif %}
+    {% for attr in c.attributes.values() if c.attributes -%}
+    {{attr.name}}: {{ attr.annotations['python_range'].value }} = Field(
+    {%- if predefined_slot_values[c.name][attr.name] -%}
+        {{ predefined_slot_values[c.name][attr.name] }}
+    {%- elif (attr.required or attr.identifier or attr.key) -%}
+        ...
+    {%- else -%}
+        None
+    {%- 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 -%}
+     {%- if attr.maximum_value != None %}, le={{attr.maximum_value}}{% endif -%}
+    {%- endif -%}
+    )
+    {% else -%}
+    None
+    {% endfor %}
+{% endfor %}
+"""
+    elif pydantic_ver == "2":
+        template += """
 {%- for c in schema.classes.values() %}
 class {{ c.name }}
     {%- if class_isa_plus_mixins[c.name] -%}
@@ -133,6 +172,7 @@ 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 -%}
@@ -144,6 +184,7 @@ class {{ c.name }}
     {% endfor %}
 {% endfor %}
 """
+
     ### FWD REFS / REBUILD MODEL ###
     if pydantic_ver == "1":
         template += """

linkml/generators/pythongen.py

@@ -509,6 +509,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         initializers += [self.gen_class_variable(cls, slot, False) for slot in slot_variables]
 
         # Followed by everything else
+
         slot_variables = self._slot_iter(cls, lambda slot: not slot.required and slot in domain_slots)
         initializers += [self.gen_class_variable(cls, slot, False) for slot in slot_variables]
 
@@ -604,7 +605,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def class_reference_type(self, slot: SlotDefinition, cls: Optional[ClassDefinition]) -> Tuple[str, str, str]:
         """
-        Return the type of a slot referencing a class
+        Return the type of slot referencing a class
 
         :param slot: slot to be typed
         :param cls: owning class.  Used for generating key references
@@ -734,6 +735,12 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         return typ_name
 
     def gen_constructor(self, cls: ClassDefinition) -> Optional[str]:
+        """
+        Generate python constructor for class
+
+        :param cls: class to generate constructor for
+        :return: python constructor
+        """
         rlines: List[str] = []
         designators = [x for x in self.domain_slots(cls) if x.designates_type]
         if len(designators) > 0:
@@ -845,7 +852,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         elif slot.inlined:
             slot_range_cls = self.schema.classes[slot.range]
             identifier = self.class_identifier(slot_range_cls)
-            # If we don't have an identifier and we are expecting to be inlined first class elements
+            # If we don't have an identifier, and we are expecting to be inlined first class elements
             # (inlined_as_list is not True), we will use the first required field as the key.
             #  Note that this may not always work, but the workaround is straight forward -- set inlined_as_list to
             #  True

linkml/utils/generator.py

@@ -223,7 +223,7 @@ class Generator(metaclass=abc.ABCMeta):
         else:
             if isinstance(schema, SchemaDefinition):
                 # schemaloader based methods require schemas to have been created via SchemaLoader,
-                # which prepopulates some fields (e.g definition_url). If the schema has not been processed through the
+                # which prepopulates some fields (e.g. definition_url). If the schema has not been processed through the
                 # loader, then roundtrip
                 if any(c for c in schema.classes.values() if not c.definition_uri):
                     schema = yaml_dumper.dumps(schema)
@@ -339,11 +339,11 @@ class Generator(metaclass=abc.ABCMeta):
 
     def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> None:
         """Visited for each slot in a class.  If class level visit_all_slots is true, this is visited once
-        for any class that is inherited (class itself, is_a, mixin, apply_to).  Otherwise just the own slots.
+        for any class that is inherited (class itself, is_a, mixin, apply_to).  Otherwise, just the own slots.
 
         @param cls: containing class
         @param aliased_slot_name: Aliased slot name.  May not be unique across all class slots
-        @param slot: slot being visited
+        @param slot: being visited
         """
         ...
 
@@ -758,11 +758,28 @@ class Generator(metaclass=abc.ABCMeta):
     # TODO: add lru cache once we get identity into the classes
     def domain_slots(self, cls: ClassDefinition) -> List[SlotDefinition]:
         """Return all slots in the class definition that are owned by the class"""
-        return [
-            slot
-            for slot in [self.schema.slots[sn] for sn in cls.slots]
-            if cls.name in slot.domain_of or (set(cls.mixins).intersection(slot.domain_of))
-        ]
+        domain_slots = []
+        for slot_name in cls.slots:
+            slot = self.schema.slots[slot_name]
+
+            # add any mixin ancestors here so that slots will be distributed to descendents correctly via mixin
+            # hierarchy.
+            mixin_ancestors = []
+            if cls.mixins:
+                for mixin in cls.mixins:
+                    for ancestor in self.schemaview.class_ancestors(mixin, mixins=False):
+                        if ancestor not in mixin_ancestors:
+                            mixin_ancestors.append(ancestor)
+
+            for mixin_ancestor in mixin_ancestors:
+                if mixin_ancestor not in cls.mixins:
+                    cls.mixins.append(mixin_ancestor)
+
+            # Check if the class is in the domain of the slot or if any of its mixins are in the domain
+            if cls.name in slot.domain_of or (set(cls.mixins).intersection(slot.domain_of)):
+                domain_slots.append(slot)
+
+        return domain_slots
 
     def add_mappings(self, defn: Definition) -> None:
         """

linkml/utils/schemaloader.py

@@ -691,7 +691,7 @@ class SchemaLoader:
                         cls.is_a,
                     )
             for mixin in cls.mixins:
-                # Note that apply_to has ben injected as a faux mixin so it gets covered here
+                # Note that apply_to has been injected as a faux mixin, so it gets covered here
                 if mixin in self.schema.classes:
                     self.merge_class(self.schema.classes[mixin], merged_classes)
                     merge_classes(self.schema, cls, self.schema.classes[mixin], True)

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

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

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

@@ -19,7 +19,7 @@ linkml/generators/docgen/type.md.jinja2,sha256=QmCMJZrFwP33eHkggBVtypbyrxTb-XZn9
 linkml/generators/docgen.py,sha256=zsLzbXN2t9pafQubEnb7QshufMKBMqUWjdLE1OyFyq8,33296
 linkml/generators/dotgen.py,sha256=CnbVY6CO1OMuiYXYnvxgNN2IW1mtOQW-J-QnwZlXkUI,5012
 linkml/generators/erdiagramgen.py,sha256=Gu-_nhLuEPTsYYaoV6tNS1V6cZ2dNJdm6YwxC0VGl7g,10315
-linkml/generators/excelgen.py,sha256=uFc8xOCeBhWhWdHPTepotBBaIQPtBA6MkFfVtiKWGhw,6699
+linkml/generators/excelgen.py,sha256=ClzWs3wO-QjH2XzzQVUsGF2n6fnoozmXopxPYDEJyPs,7232
 linkml/generators/golanggen.py,sha256=Dnl7dhmb1AIK3Is7KRaUbxPd3kBTjWuspFqardiBTJ8,5751
 linkml/generators/golrgen.py,sha256=tIsbsr4SM9HxeK7TCUwnq-GdSKZ_qW5f7fybg_aqCZE,3436
 linkml/generators/graphqlgen.py,sha256=6qZpI0rwg3ypsv_KrLVzXgdsJfR8LNPqgMwaRwzwnDs,2151
@@ -39,8 +39,8 @@ linkml/generators/plantumlgen.py,sha256=Vs__5x9ioiT4IBTbvZUpgT8MsYJ0amfBL64MB_nm
 linkml/generators/prefixmapgen.py,sha256=JJ7hgzuqKVfFZrbDV76Dk8dR2NHsmpp-eNUAspXkfwA,4626
 linkml/generators/projectgen.py,sha256=EVgS5bDzFTm3WAuMg3lC3rzdcaW-hgpq99qZA4nksSY,9544
 linkml/generators/protogen.py,sha256=9YfxBZkQdBWwsUbstxEUR4xRWNuAKSfz9zXPhgIYePU,2328
-linkml/generators/pydanticgen.py,sha256=CiUHkThpYcVzSkWb4IODhteKau3z-ZQ7yQpFA9dSRGw,22298
-linkml/generators/pythongen.py,sha256=DBsZNa9T3fGW4Qw0_l8N72f_DeUEugvcbRN9FJLi1QM,52166
+linkml/generators/pydanticgen.py,sha256=rH__R3Pt7TKQzG2DBo1R5OehQG3FaBMCjXBzZlAWMqw,23742
+linkml/generators/pythongen.py,sha256=7XNlOpScOOpxpo9Q_sasDOZFYaKifbXWQL-OKczpkfY,52327
 linkml/generators/rdfgen.py,sha256=LxzYBaFEkV7rlf54nWv_6H6AGcWMRXwkaeVXq9VYEc8,2693
 linkml/generators/shaclgen.py,sha256=KxNmDZW2ciCuSqUhJ65TxLTjF8jME1FmN5SaWJCuW9k,8662
 linkml/generators/shexgen.py,sha256=Awtn5SyjS-TUcVCwMdT0F7hNO4K8VcSCYBaFru45Mwg,8994
@@ -86,7 +86,7 @@ linkml/utils/converter.py,sha256=rdhCI7Tsjddr3o1rVBfMq5gQubk_GE6fqlBBmyxI5_M,627
 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=74g3s5FVpOqfOtkMTrpk0k95ny2-kSFc0AvcSlKgka0,38320
+linkml/utils/generator.py,sha256=dW9kfVL-7an0ieXR5HLe8bqOyEgDGAoIzdLOu_TFQhc,39101
 linkml/utils/helpers.py,sha256=yR8n4zFA5wPcYC7xzRuNF3wO16vG80v6j7DM3qTNmIc,447
 linkml/utils/ifabsent_functions.py,sha256=FZwceqwlq81lMPDsdNfSHhtzDXSf8F4cbbhRdnDzjss,5765
 linkml/utils/logictools.py,sha256=GSmBiobC49TcQjE08RtXEE3JwJEOV7eEREio25uJiFs,21184
@@ -94,7 +94,7 @@ linkml/utils/mergeutils.py,sha256=QVm2iQB4v_L2rSvPBsPe9C865R03BgV3TzlPoTTTwWQ,90
 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/schemaloader.py,sha256=Ju1QCJPdNbLkXzTyvXmv7Bpk6EQ07Hzh7qgeYdiyTU8,46419
+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
 linkml/utils/typereferences.py,sha256=8Yfuz9-HAwOPoJLbIcO_sY9zf32hvPRzGeSOzECfMWA,2232
@@ -123,8 +123,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=hblnsZVntuwFO4vqcwl_K5XH6jxb52xCtvdc7Sfq_Yc,11452
-linkml-1.6.4.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
-linkml-1.6.4.dist-info/METADATA,sha256=rXsZaS97nlj9NvQH1poCuvB_xzVjmzg6UGzydhsrwSA,3496
-linkml-1.6.4.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.6.4.dist-info/entry_points.txt,sha256=za8r49Z5gcz3rAYTZLbxw5EPZr1rGuxSe1uiRUpf8R0,2143
-linkml-1.6.4.dist-info/RECORD,,
+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,,