linkml 1.9.3rc1__py3-none-any.whl → 1.9.3rc2__py3-none-any.whl

linkml/generators/docgen/subset.md.jinja2

@@ -1,4 +1,4 @@
-# Subset: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
+# Subset: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong></span> {% endif %}
 
 {%- if header -%}
 {{ header }}
@@ -45,7 +45,7 @@ URI: {{ gen.link(element) }}
 | --- | --- |
 {% for c in classes_in_subset -%}
 {%- if element.name in c.in_subset -%}
-| {{gen.link(c)}} | {{c.description|enshorten}} |
+| {{ gen.link(c) }} | {{ c.description|enshorten }} |
 {% endif -%}
 {% endfor %}
 
@@ -67,17 +67,15 @@ URI: {{ gen.link(element) }}
 | Name | Cardinality and Range | Description |
 | ---  | ---  | --- |
 {% for s in filtered_slots -%}
-| {{gen.link(s)}} | {{ gen.cardinality(s) }} <br/> {{gen.link(s.range)}} | {{s.description|enshorten}} {% if s.identifier %}**identifier**{% endif %} |
+| {{ gen.link(s) }} | {{ gen.cardinality(s) }} <br/> {{ gen.link(s.range) }} | {{ s.description|enshorten }} {% if s.identifier %}**identifier**{% endif %} |
 {% endfor %}
 {%- endif %}
 
-
 {%- endif %}
 {% endfor %}
 
 {%- endif %}
 
-
 {% if slots_in_subset %}
 ## Slots in subset
 
@@ -91,14 +89,13 @@ URI: {{ gen.link(element) }}
 
 {%- endif %}
 
-
 {% if enums_in_subset %}
 ## Enumerations in subset
 
 | Enumeration | Description |
 | --- | --- |
 {% for e in enums_in_subset|sort(attribute='name') -%}
-{%- if element.name in e.in_subset %}
+{% if element.name in e.in_subset -%}
 | {{ gen.link(e) }} | {{ e.description|enshorten }} |
 {%- endif %}
 {% endfor %}

linkml/generators/docgen/type.md.jinja2

@@ -1,4 +1,4 @@
-# Type: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
+# Type: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong></span> {% endif %}
 
 {% if element.description %}
 {% set element_description_lines = element.description.split('\n') %}
@@ -15,8 +15,7 @@ URI: {{ gen.uri_link(element) }}
 {{ gen.bullet(element, "typeof") }}
 {{ gen.bullet(element, "pattern", backquote=True) }}
 {% if gen.number_value_range(element) %}
-* Numeric Value Range: {{gen.number_value_range(element)}}
+* Numeric Value Range: {{ gen.number_value_range(element) }}
 {% endif %}
 
 {% include "common_metadata.md.jinja2" %}
-

linkml/generators/docgen.py

@@ -6,11 +6,11 @@ from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import click
 from jinja2 import Environment, FileSystemLoader, Template
-from linkml_runtime.dumpers import yaml_dumper
+from linkml_runtime.dumpers import json_dumper, yaml_dumper
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
     ClassDefinitionName,
@@ -410,6 +410,21 @@ class DocGenerator(Generator):
         curie = self.uri(element, expand=False)
         return f"[{curie}]({uri})"
 
+    def link_mermaid(self, e: Union[Definition, DefinitionName]) -> str:
+        """
+        Return link to insert in mermaid diagrams for a given element
+
+        :param e: element to be linked
+        :return: string with link
+        """
+        # Reuse markdown link generation to avoid code duplication.
+        md_link = self.link(e)
+        if not md_link.endswith(")"):
+            return md_link
+        link = md_link.rsplit("(")[-1][:-1]
+        link = link.removesuffix(".md")
+        return f"../{link}/"
+
     def link(self, e: Union[Definition, DefinitionName], index_link: bool = False) -> str:
         """
         Render an element as a hyperlink
@@ -485,14 +500,13 @@ class DocGenerator(Generator):
         return self._is_external(t) and not self.schemaview.schema.id.startswith("https://w3id.org/linkml/")
 
     def _is_external(self, element: Element) -> bool:
-        # note: this is currently incomplete. See: https://github.com/linkml/linkml/issues/782
         if element.from_schema == "https://w3id.org/linkml/types" and not self.genmeta:
             return True
         else:
             return False
 
     @staticmethod
-    def _markdown_link(n: str, name: str = None, subfolder: str = None) -> str:
+    def _markdown_link(n: str, name: str = "", subfolder: str = "") -> str:
         if subfolder:
             rel_path = f"{subfolder}/{n}"
         else:
@@ -965,6 +979,80 @@ class DocGenerator(Generator):
                 objs.append((stem, f.read()))
         return objs
 
+    def _remove_name_keys(self, obj):
+        """Recursively removes 'name' keys from a JSON object representation.
+
+        This is used to clean up the output of ClassRule objects. For example, if we had a rule like:
+        rules:
+        - title: calibration_standard_if_rt
+            preconditions:
+                slot_conditions:
+                    calibration_target:
+                        equals_string: retention_index
+
+        The JSON representation would include redundant "name" keys:
+        {
+            "slot_conditions": {
+                "name": "slot_conditions"
+                "calibration_target": {
+                    "name": "calibration_target"
+                    "equals_string": "retention_index",
+                },
+            }
+        }
+
+        This function removes those redundant "name" keys to make the output cleaner.
+
+        :param obj: The object to clean (dict, list, or primitive value)
+        :return: The same object with all "name" keys removed from dicts
+        """
+        if isinstance(obj, dict):
+            return {k: self._remove_name_keys(v) for k, v in obj.items() if k != "name"}
+        elif isinstance(obj, list):
+            return [self._remove_name_keys(item) for item in obj]
+        else:
+            return obj
+
+    def classrule_to_dict_view(self, element: ClassDefinition) -> list[dict[str, Any]]:
+        """Process all rules (of type ClassRule) asserted on a class.
+
+        This method iterates through all rules asserted on a class and returns a list of
+        dictionaries, each containing four pieces of information about a rule:
+        _title_, _preconditions_, _postconditions_, and _elseconditions_.
+        These values will be read in the jinja template and formatted into a tabular
+        view for users to understand the rules applied to the class.
+
+        Note: This method removes redundant "name" keys which are asserted on some
+        classes in the Python representation of classes from the metamodel.
+
+        :param element: LinkML class object with `rules` asserted on it
+        :return: List of dictionaries with title and "sanitized" conditions for each rule
+        """
+        if not element.rules:
+            return []
+
+        rule_dicts = []
+
+        for rule in element.rules:
+            # TODO: expand this list of ClassRule metaslots based on use case
+            rule_dict = {
+                "title": rule.title or "",
+                "preconditions": None,
+                "postconditions": None,
+                "elseconditions": None,
+            }
+
+            for key in ["preconditions", "postconditions", "elseconditions"]:
+                condition_obj = getattr(rule, key, None)
+                if condition_obj:
+                    json_obj = json_dumper.to_dict(condition_obj)
+                    sanitized_condition = self._remove_name_keys(json_obj)
+                    rule_dict[key] = sanitized_condition
+
+            rule_dicts.append(rule_dict)
+
+        return rule_dicts
+
     def customize_environment(self, env: Environment):
         if self.truncate_descriptions:
             env.filters["enshorten"] = enshorten

linkml/generators/erdiagramgen.py

@@ -23,7 +23,7 @@ class Attribute(pydantic.BaseModel):
 
     def __str__(self):
         cmt = f'"{self.comment}"' if self.comment else ""
-        return f'    {self.datatype} {self.name} {self.key if self.key else ""} {cmt}'
+        return f"    {self.datatype} {self.name} {self.key if self.key else ''} {cmt}"
 
 
 class IdentifyingType(str, Enum):

linkml/generators/graphqlgen.py

@@ -66,7 +66,7 @@ class GraphqlGenerator(Generator):
             for value in enum.permissible_values:
                 permissible_values.append(self.name_compatiblity.compatible(value))
             values = "\n    ".join(permissible_values)
-            return f"enum {camelcase(enum.name).replace(' ','')}\n  {{\n    {values}\n  }}\n\n"
+            return f"enum {camelcase(enum.name).replace(' ', '')}\n  {{\n    {values}\n  }}\n\n"
         else:
             logging.warning(
                 f"Enumeration {enum.name} using `reachable_from` instead of `permissible_values` "

linkml/generators/javagen/example_template.java.jinja2

@@ -19,4 +19,3 @@ public class {{ cls.name }} {% if cls.is_a -%} extends {{ cls.is_a }} {%- endif
 {%- endfor %}
 
 }
-

linkml/generators/jsonldcontextgen.py

@@ -197,7 +197,6 @@ class ContextGenerator(Generator):
         elif not uri_prefix or is_default_namespace:
             definition["@id"] = uri_suffix
         else:
-
             definition["@id"] = (uri_prefix + ":" + uri_suffix) if uri_prefix else uri
 
         if uri_prefix and not is_default_namespace:

linkml/generators/jsonldgen.py

@@ -106,7 +106,9 @@ class JSONLDGenerator(Generator):
                     else (
                         SubsetDefinitionName(camelcase(node))
                         if node in self.schema.subsets
-                        else TypeDefinitionName(underscore(node)) if node in self.schema.types else None
+                        else TypeDefinitionName(underscore(node))
+                        if node in self.schema.types
+                        else None
                     )
                 )
             )

linkml/generators/jsonschemagen.py

@@ -694,8 +694,8 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
         if self.materialize_patterns:
             logger.info("Materializing patterns in the schema before serialization")
             self.schemaview.materialize_patterns()
-
-        return self.generate().to_json(sort_keys=True, indent=self.indent if self.indent > 0 else None)
+        result = self.generate().to_json(sort_keys=True, indent=self.indent if self.indent > 0 else None)
+        return result.rstrip() + "\n"
 
 
 @shared_arguments(JsonSchemaGenerator)

linkml/generators/linkmlgen.py

@@ -73,7 +73,7 @@ class LinkmlGenerator(Generator):
             return yaml_str
         else:
             raise ValueError(
-                f"{self.format} is an invalid format. Use one of the following " f"formats: {self.valid_formats}"
+                f"{self.format} is an invalid format. Use one of the following formats: {self.valid_formats}"
             )
 
 

linkml/generators/markdowngen.py

@@ -149,6 +149,7 @@ class MarkdownGenerator(Generator):
             items = [i for i in items if i is not None]
             out = "\n".join(items) + "\n"
             out = pad_heading(out)
+            out = out.rstrip() + "\n"
             ixfile.write(out)
         return out
 
@@ -179,7 +180,7 @@ class MarkdownGenerator(Generator):
                     yg = YumlGenerator(self)
                     img_url = (
                         yg.serialize(classes=[cls.name]).replace("?", "%3F").replace(" ", "%20").replace("|", "|")
-                    )
+                    ).rstrip()
 
                 items.append(f"[![img]({img_url})]({img_url})")
 
@@ -204,7 +205,7 @@ class MarkdownGenerator(Generator):
             if cls.name in self.synopsis.mixinrefs:
                 items.append(self.header(2, f"{mixin_local_name} for"))
                 for mixin in sorted(self.synopsis.mixinrefs[cls.name].classrefs):
-                    items.append(self.bullet(f'{self.class_link(mixin, use_desc=True, after_link="(mixin)")}'))
+                    items.append(self.bullet(f"{self.class_link(mixin, use_desc=True, after_link='(mixin)')}"))
 
             if cls.name in self.synopsis.classrefs:
                 items.append(self.header(2, f"Referenced by {class_local_name}"))
@@ -253,6 +254,7 @@ class MarkdownGenerator(Generator):
             items.append(self.element_properties(cls))
             out = "\n".join(items)
             out = pad_heading(out)
+            out = out.rstrip() + "\n"
             clsfile.write(out)
         return out
 
@@ -272,6 +274,7 @@ class MarkdownGenerator(Generator):
             out += self.element_properties(typ)
             out += "\n"
             out = pad_heading(out)
+            out = out.rstrip() + "\n"
             typefile.write(out)
         return out
 
@@ -312,6 +315,7 @@ class MarkdownGenerator(Generator):
             items.append(self.element_properties(slot))
             out = "\n".join(items)
             out = pad_heading(out)
+            out = out.rstrip() + "\n"
             slotfile.write(out)
         return out
 
@@ -324,6 +328,7 @@ class MarkdownGenerator(Generator):
             items.append(self.element_properties(enum))
             out = "\n".join(items)
             out = pad_heading(out)
+            out = out.rstrip() + "\n"
             enumfile.write(out)
         return out
 
@@ -359,6 +364,7 @@ class MarkdownGenerator(Generator):
             items.append(self.element_properties(subset))
             out = "\n".join(items)
             out = pad_heading(out)
+            out = out.rstrip() + "\n"
             subsetfile.write(out)
         return out
 
@@ -513,7 +519,9 @@ class MarkdownGenerator(Generator):
             else (
                 underscore(obj.name)
                 if isinstance(obj, SlotDefinition)
-                else underscore(obj.name) if isinstance(obj, EnumDefinition) else camelcase(obj.name)
+                else underscore(obj.name)
+                if isinstance(obj, EnumDefinition)
+                else camelcase(obj.name)
             )
         )
         subdir = "/types" if isinstance(obj, TypeDefinition) and not self.no_types_dir else ""
@@ -548,7 +556,7 @@ class MarkdownGenerator(Generator):
         for example in slot.examples:
             items.append(
                 self.bullet(
-                    f'Example: {getattr(example, "value", " ")} {getattr(example, "description", " ")}',
+                    f"Example: {getattr(example, 'value', ' ')} {getattr(example, 'description', ' ')}",
                     level=1,
                 )
             )
@@ -599,7 +607,7 @@ class MarkdownGenerator(Generator):
 
     def header(self, level: int, txt: str) -> str:
         txt = self.get_metamodel_slot_name(txt)
-        out = f'\n{"#" * level} {txt}\n'
+        out = f"\n{'#' * level} {txt}\n"
         return out
 
     @staticmethod
@@ -608,7 +616,7 @@ class MarkdownGenerator(Generator):
 
     @staticmethod
     def bullet(txt: str, level=0) -> str:
-        return f'{"    " * level} * {txt}'
+        return f"{'    ' * level} * {txt}"
 
     def frontmatter(self, thingtype: str, layout="default") -> str:
         return self.header(1, thingtype)
@@ -674,9 +682,12 @@ class MarkdownGenerator(Generator):
             link_name = obj.name
             link_ref = link_name
         desc = self.desc_for(obj, use_desc)
-        return f"[{link_name}]" f"({link_ref}.{self.format})" + (f" {after_link} " if after_link else "") + (
-            f" - {desc.split(nl)[0]}" if desc else ""
-        )
+        return (
+            f"[{link_name}]"
+            f"({link_ref}.{self.format})"
+            + (f" {after_link} " if after_link else "")
+            + (f" - {desc.split(nl)[0]}" if desc else "")
+        ).rstrip()
 
     def type_link(
         self,

linkml/generators/mermaidclassdiagramgen.py

@@ -90,6 +90,10 @@ class MermaidClassDiagramGenerator(Generator):
         """Returns the canonical name for an element."""
         return element.name
 
+    def link_mermaid(self, element):
+        """Generates a link for the given element."""
+        return f"../{self.name(element)}"
+
     def all_type_object_names(self):
         return list(self.schemaview.all_types().keys())
 

linkml/generators/projectgen.py

@@ -1,5 +1,4 @@
 import logging
-import os
 from collections import defaultdict
 from dataclasses import dataclass, field
 from functools import lru_cache
@@ -45,7 +44,7 @@ GEN_MAP = {
     "markdown": (
         MarkdownGenerator,
         "docs/",
-        {"directory": "{parent}", "index_file": "{name}.md"},
+        {"directory": "{parent}/docs", "index_file": "{name}.md"},
     ),
     "owl": (OwlSchemaGenerator, "owl/{name}.owl.ttl", {}),
     "prefixmap": (PrefixGenerator, "prefixmap/{name}.yaml", {}),
@@ -64,17 +63,16 @@ GEN_MAP = {
 
 
 @lru_cache
-def get_local_imports(schema_path: str, dir: str):
+def get_local_imports(schema_path: Path, dir: Path):
     logger.info(f"GETTING IMPORTS = {schema_path}")
     all_imports = [schema_path]
-    with open(schema_path) as stream:
-        with open(schema_path) as stream:
-            schema = yaml.safe_load(stream)
-            for imp in schema.get("imports", []):
-                imp_path = os.path.join(dir, imp) + ".yaml"
-                logger.info(f" IMP={imp} //  path={imp_path}")
-                if os.path.isfile(imp_path):
-                    all_imports += get_local_imports(imp_path, dir)
+    with open(schema_path, encoding="utf-8") as stream:
+        schema = yaml.safe_load(stream)
+        for imp in schema.get("imports", []):
+            imp_path = dir / f"{imp}.yaml"
+            logger.info(f" IMP={imp} //  path={imp_path}")
+            if imp_path.is_file():
+                all_imports += get_local_imports(imp_path, dir)
     return all_imports
 
 
@@ -102,11 +100,12 @@ class ProjectGenerator:
     def generate(schema_path: str, config: ProjectConfiguration = ProjectConfiguration()):
         if config.directory is None:
             raise Exception("Must pass directory")
-        Path(config.directory).mkdir(parents=True, exist_ok=True)
+        output_dir = Path(config.directory)
+        output_dir.mkdir(parents=True, exist_ok=True)
         if config.mergeimports:
             all_schemas = [schema_path]
         else:
-            all_schemas = get_local_imports(schema_path, os.path.dirname(schema_path))
+            all_schemas = get_local_imports(schema_path, Path(schema_path).parent)
         logger.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:
@@ -118,14 +117,12 @@ class ProjectGenerator:
             logger.info(f"Generating: {gen_name}")
             for local_path in all_schemas:
                 logger.info(f" SCHEMA: {local_path}")
-                name = os.path.basename(local_path).replace(".yaml", "")
+                name = Path(local_path).stem
                 gen_path = gen_path_fmt.format(name=name)
-                gen_path_full = f"{config.directory}/{gen_path}"
-                parts = gen_path_full.split("/")
-                parent_dir = "/".join(parts[0:-1])
+                gen_path_full = output_dir / gen_path
+                parent_dir = gen_path_full.parent
                 logger.info(f" PARENT={parent_dir}")
-                Path(parent_dir).mkdir(parents=True, exist_ok=True)
-                gen_path_full = "/".join(parts)
+                parent_dir.mkdir(parents=True, exist_ok=True)
                 all_gen_args = {
                     **default_gen_args,
                     **config.generator_args.get(gen_name, {}),
@@ -149,7 +146,7 @@ class ProjectGenerator:
                 gen_dump = gen.serialize(**serialize_args)
 
                 if gen_name != "excel":
-                    if parts[-1] != "":
+                    if gen_path_full.suffix != "":
                         # markdowngen does not write to a file
                         logger.info(f"  WRITING TO: {gen_path_full}")
                         with open(gen_path_full, "w", encoding="UTF-8") as stream:

linkml/generators/pydanticgen/includes.py

@@ -6,17 +6,17 @@ LinkMLMeta = """
 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
-        
+
     def __contains__(self, key:str) -> bool:
         return key in self.root
-    
+
 """

linkml/generators/pydanticgen/pydanticgen.py

@@ -832,8 +832,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             meta = remove_empty_items(source)
         else:
             raise ValueError(
-                f"Unknown metadata mode '{self.metadata_mode}', needs to be one of "
-                f"{[mode for mode in MetadataMode]}"
+                f"Unknown metadata mode '{self.metadata_mode}', needs to be one of {[mode for mode in MetadataMode]}"
             )
 
         model.meta = meta

linkml/generators/pydanticgen/template.py

@@ -596,7 +596,7 @@ class Imports(PydanticTemplateModel):
             else:
                 return all([obj in an_import.objects for obj in item.objects])
         else:
-            raise TypeError("Imports only contains single Import objects or other Imports\n" f"Got: {type(item)}")
+            raise TypeError(f"Imports only contains single Import objects or other Imports\nGot: {type(item)}")
 
     @field_validator("imports", mode="after")
     @classmethod

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

@@ -13,4 +13,4 @@ class {{ name }}(BaseModel):
     {% endfor %}
 {% else %}
     {{ "pass" }}
-{% endif %}
+{% endif %}

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

@@ -22,4 +22,4 @@ class {{ name }}({% if bases is string %}{{ bases }}{% else %}{{ bases | join(',
         {% endif %}
     {% else %}
     pass
-    {% endif %}
+    {% endif %}

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

@@ -6,4 +6,4 @@ if {{ condition }}:
 else:
     {% filter indent(width=4) %}
     {{ alternative }}
-    {% endfilter %}
+    {% endfilter %}

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

@@ -2,4 +2,4 @@
 # see https://pydantic-docs.helpmanual.io/usage/models/#rebuilding-a-model
 {% for c in class_names -%}
 {{ c }}.model_rebuild()
-{% endfor %}
+{% endfor %}

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

@@ -36,4 +36,4 @@ from {{ module }} import (
 {{ import }}
         {%- endfor -%}
     {%- endif -%}
-{% endif -%}
+{% endif -%}

linkml/generators/python/python_ifabsent_processor.py

@@ -57,7 +57,7 @@ class PythonIfAbsentProcessor(IfAbsentProcessor):
         slot: SlotDefinition,
         cls: ClassDefinition,
     ):
-        return f"datetime({int(year)}, {int(month)}, {int(day)}, " f"{int(hour)}, {int(minutes)}, {int(seconds)})"
+        return f"datetime({int(year)}, {int(month)}, {int(day)}, {int(hour)}, {int(minutes)}, {int(seconds)})"
 
     def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
         return self._uri_for(default_value)

linkml/generators/pythongen.py

@@ -474,7 +474,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
     def gen_classdef(self, cls: ClassDefinition) -> str:
         """Generate python definition for class cls"""
 
-        parentref = f'({self.formatted_element_name(cls.is_a, True) if cls.is_a else "YAMLRoot"})'
+        parentref = f"({self.formatted_element_name(cls.is_a, True) if cls.is_a else 'YAMLRoot'})"
         slotdefs = self.gen_class_variables(cls)
         postinits = self.gen_postinits(cls)
         constructor = self.gen_constructor(cls)
@@ -833,8 +833,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
                 elif slot_range == "uri":
                     lookup_by_props = ["class_class_uri", "class_model_uri"]
                     td_val_expression = (
-                        f"URIRef({td_val_expression}) if "
-                        f"isinstance({td_val_expression}, str) else {td_val_expression}"
+                        f"URIRef({td_val_expression}) if isinstance({td_val_expression}, str) else {td_val_expression}"
                     )
                 elif slot_range == "uriorcurie":
                     lookup_by_props = ["class_class_curie", "class_class_uri", "class_model_uri"]
@@ -917,8 +916,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
                 rlines.append(f"self.{aliased_slot_name} = str(self.{td_value_classvar})")
             elif (
                 # A really weird case -- a class that has no properties
-                slot.range in self.schema.classes
-                and not self.schema.classes[slot.range].slots
+                slot.range in self.schema.classes and not self.schema.classes[slot.range].slots
             ):
                 rlines.append(f"\tself.{aliased_slot_name} = {base_type_name}()")
             else:
@@ -985,7 +983,7 @@ version = {'"' + self.schema.version + '"' if self.schema.version else None}
             sn = f"self.{aliased_slot_name}"
             rlines.append(f"if not isinstance({sn}, list):")
             rlines.append(f"\t{sn} = [{sn}] if {sn} is not None else []")
-            rlines.append(f"{sn} = [v if isinstance(v, {base_type_name}) " f"else {base_type_name}(v) for v in {sn}]")
+            rlines.append(f"{sn} = [v if isinstance(v, {base_type_name}) else {base_type_name}(v) for v in {sn}]")
         while rlines and copy(rlines[-1]).strip() == "":
             rlines.pop()
         rlines.append("")
@@ -1213,6 +1211,7 @@ class {enum_name}(EnumDefinitionImpl):
         PermissibleValue(text="NAME_ONLY")
         PermissibleValue(
             text="CODE",
+            title="...",
             description="...",
             meaning="...")
 
@@ -1223,13 +1222,15 @@ class {enum_name}(EnumDefinitionImpl):
         constructor = "PermissibleValue"
         pv_text = pv.text.replace('"', '\\"')
 
-        if not pv.description and not pv.meaning:
+        if not pv.description and not pv.meaning and not pv.title:
             return f'{constructor}(text="{pv_text}")'
 
         indent_str = (4 + indent) * " "
         pv_attrs = [f'{indent_str}text="{pv_text}"']
+        if pv.title:
+            pv_attrs.append(f'{indent_str}title="{pv.title}"')
         if pv.description:
-            pv_attrs.append(f'{self.process_multiline_string(pv.description, f"{indent_str}description=")}')
+            pv_attrs.append(f"{self.process_multiline_string(pv.description, f'{indent_str}description=')}")
         if pv.meaning:
             pv_meaning = self.namespaces.curie_for(
                 self.namespaces.uri_for(pv.meaning), default_ok=False, pythonform=True

linkml/generators/shacl/shacl_ifabsent_processor.py

@@ -6,7 +6,6 @@ from linkml.generators.shacl.shacl_data_type import ShaclDataType
 
 
 class ShaclIfAbsentProcessor(IfAbsentProcessor):
-
     def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
         if default_value == "class_curie":
             class_uri = self.schema_view.get_uri(cls, expand=True)

linkml/generators/shaclgen.py

@@ -141,7 +141,7 @@ class ShaclGenerator(Generator):
                     # 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(str(s), suffix="")} {error}')
+                        raise ValueError(f"{TypedNode.yaml_loc(str(s), suffix='')} {error}")
 
                     or_node = BNode()
                     prop_pv(SH["or"], or_node)