linkml 1.6.4__py3-none-any.whl → 1.6.6__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/owlgen.py

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

linkml/generators/projectgen.py

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

linkml/generators/pydanticgen.py

@@ -44,14 +44,14 @@ from __future__ import annotations
 from datetime import datetime, date
 from enum import Enum
 from typing import List, Dict, Optional, Any, Union"""
-    if pydantic_ver == 1:
+    if pydantic_ver == "1":
         template += """
-from pydantic import BaseModel as BaseModel, Field"""
-    else:
+from pydantic import BaseModel as BaseModel, Field, validator"""
+    elif pydantic_ver == "2":
         template += """
-from pydantic import BaseModel as BaseModel, ConfigDict, Field"""
-
+from pydantic import BaseModel as BaseModel, ConfigDict,  Field, field_validator"""
     template += """
+import re
 import sys
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -108,7 +108,8 @@ 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] -%}
@@ -142,8 +143,76 @@ class {{ c.name }}
     {% else -%}
     None
     {% endfor %}
+    {% for attr in c.attributes.values() if c.attributes -%}
+    {%- if attr.pattern %}
+    @validator('{{attr.name}}', allow_reuse=True)
+    def pattern_{{attr.name}}(cls, v):
+        pattern=re.compile(r"{{attr.pattern}}")
+        if isinstance(v,list):
+            for element in v:
+                if not pattern.match(element):
+                    raise ValueError(f"Invalid {{attr.name}} format: {element}")
+        elif isinstance(v,str):
+            if not pattern.match(v):
+                raise ValueError(f"Invalid {{attr.name}} format: {v}")
+        return v
+    {% endif -%}
+    {% endfor %}    
 {% endfor %}
 """
+    elif pydantic_ver == "2":
+        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.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 %}
+    {% for attr in c.attributes.values() if c.attributes -%}
+    {%- if attr.pattern %}
+    @field_validator('{{attr.name}}')
+    def pattern_{{attr.name}}(cls, v):
+        pattern=re.compile(r"{{attr.pattern}}")
+        if isinstance(v,list):
+            for element in v:
+                if not pattern.match(element):
+                    raise ValueError(f"Invalid {{attr.name}} format: {element}")
+        elif isinstance(v,str):
+            if not pattern.match(v):
+                raise ValueError(f"Invalid {{attr.name}} format: {v}")
+        return v
+    {% endif -%}
+    {% endfor %}    
+{% endfor %}
+"""
+
     ### 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:
@@ -795,6 +802,11 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
             if self.is_class_unconstrained(self.schema.classes[slot.range]):
                 return ""
 
+        if slot.range in self.schema.enums:
+            # Open enum
+            if not self.schema.enums[slot.range].permissible_values:
+                return ""
+
         aliased_slot_name = self.slot_name(slot.name)  # Mangled name by which the slot is known in python
         _, _, base_type_name = self.class_reference_type(slot, cls)
 
@@ -845,7 +857,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/cli_utils.py

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

linkml/utils/generator.py

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

linkml/utils/schema_fixer.py

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

linkml/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/validator/validator.py

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

linkml/workspaces/example_runner.py

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

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

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

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